home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Plus 1995 #5 & #6
/
Amiga Plus CD - 1995 - No. 5 and 6.iso
/
pd
/
netz
/
term
/
extras
/
source
/
term-source.lha
/
termAux.c
< prev
next >
Wrap
C/C++ Source or Header
|
1995-06-17
|
87KB
|
4,682 lines
/*
** termAux.c
**
** Miscellaneous support routines
**
** Copyright © 1990-1995 by Olaf `Olsen' Barthel
** All Rights Reserved
*/
#include "termGlobal.h"
/* This variable stores the current state of the
* dialing menu items.
*/
STATIC BYTE DialItemsAvailable = TRUE;
/* Current timer state. */
STATIC BYTE TimerRunning = FALSE;
STATIC VOID
StuffChar(VOID)
{
__emit(0x16C0); /* MOVE D0,(A3)+ */
}
/* SPrintf(STRPTR Buffer,STRPTR FormatString,...):
*
* Just like sprintf(), but using the ROM routines.
*/
VOID __stdargs
SPrintf(STRPTR Buffer,STRPTR FormatString,...)
{
va_list VarArgs;
va_start(VarArgs,FormatString);
RawDoFmt(FormatString,VarArgs,(VOID (*)())StuffChar,Buffer);
va_end(VarArgs);
}
/* VSPrintf(STRPTR Buffer,STRPTR FormatString,va_list VarArgs):
*
* Just like vsprintf(), but using the ROM routines.
*/
VOID __regargs
VSPrintf(STRPTR Buffer,STRPTR FormatString,va_list VarArgs)
{
RawDoFmt(FormatString,VarArgs,(VOID (*)())StuffChar,Buffer);
}
/* Atol(STRPTR Buffer):
*
* Convert ASCII representation to long word.
*/
LONG __regargs
Atol(STRPTR Buffer)
{
LONG Result;
StrToLong(Buffer,&Result);
return(Result);
}
/* StripSpaces(STRPTR String):
*
* Strip leading and trailing spaces from a string.
*/
VOID __regargs
StripSpaces(STRPTR String)
{
if(String)
{
STRPTR To = String;
WORD Len;
while(*String == ' ')
String++;
if(Len = strlen(String))
{
while(Len > 0 && String[Len - 1] == ' ')
Len--;
while(Len--)
*To++ = *String++;
}
*To = 0;
}
}
/* ReplaceWindowInfo(struct WindowInfo *NewInfo):
*
* Drop the window info into the right place.
*/
VOID __regargs
ReplaceWindowInfo(struct WindowInfo *NewInfo)
{
WORD i;
for(i = 0 ; i < WINDOW_COUNT ; i++)
{
if(WindowInfoTable[i] . ID == NewInfo -> ID)
{
CopyMem(NewInfo,&WindowInfoTable[i],sizeof(struct WindowInfo));
break;
}
}
}
/* PutWindowInfo():
*
* Store window size and position relative to
* the main window.
*/
VOID __regargs
PutWindowInfo(UBYTE ID,LONG Left,LONG Top,LONG Width,LONG Height)
{
struct WindowInfo *Info;
WORD i;
LONG WindowLeft,
WindowTop,
WindowWidth,
WindowHeight;
ULONG IntuiLock;
for(i = 0 ; i < WINDOW_COUNT ; i++)
{
if(WindowInfoTable[i] . ID == ID)
{
Info = &WindowInfoTable[i];
break;
}
}
IntuiLock = LockIBase(NULL);
WindowLeft = Window -> LeftEdge;
WindowTop = Window -> TopEdge;
WindowWidth = Window -> Width;
WindowHeight = Window -> Height;
UnlockIBase(IntuiLock);
Forbid();
Info -> WindowFlags = NULL;
if(WindowWidth == Width && WindowLeft == Left)
Info -> WindowFlags |= WC_EXPANDWIDTH;
else
{
if(Left == WindowLeft + WindowWidth)
Info -> WindowFlags |= WC_ALIGNSIDE;
if(WindowLeft == Left)
Info -> WindowFlags |= WC_ALIGNLEFT;
if(WindowLeft + WindowWidth == Left + Width)
Info -> WindowFlags |= WC_ALIGNRIGHT;
}
if(WindowHeight == Height && WindowTop == Top)
Info -> WindowFlags |= WC_EXPANDHEIGHT;
else
{
if(Top == WindowTop + WindowHeight)
Info -> WindowFlags |= WC_ALIGNBELOW;
if(WindowTop == Top)
Info -> WindowFlags |= WC_ALIGNTOP;
if(WindowTop + WindowHeight == Top + Height)
Info -> WindowFlags |= WC_ALIGNBOTTOM;
}
Info -> Left = Left;
Info -> Top = Top;
Info -> Width = Width;
Info -> Height = Height;
Permit();
}
/* GetWindowInfo():
*
* Set the window size and position in relation to
* the main window.
*/
VOID __regargs
GetWindowInfo(UBYTE ID,LONG *Left,LONG *Top,LONG *Width,LONG *Height,LONG DefWidth,LONG DefHeight)
{
struct WindowInfo *Info;
WORD i;
LONG WindowLeft,
WindowTop,
WindowWidth,
WindowHeight;
ULONG IntuiLock;
if(Window)
{
if(DefWidth && DefWidth < Window -> Width / 2)
DefWidth = Window -> Width / 2;
if(DefHeight && DefHeight < Window -> Height / 2)
DefHeight = Window -> Height / 2;
}
for(i = 0 ; i < WINDOW_COUNT ; i++)
{
if(WindowInfoTable[i] . ID == ID)
{
Info = &WindowInfoTable[i];
break;
}
}
if(Info && ID == WINDOW_MAIN)
{
*Left = Info -> Left;
*Top = Info -> Top;
return;
}
if(Window)
{
IntuiLock = LockIBase(NULL);
WindowLeft = Window -> LeftEdge;
WindowTop = Window -> TopEdge + Window -> BorderTop;
WindowWidth = Window -> Width;
WindowHeight = Window -> Height - Window -> BorderTop;
UnlockIBase(IntuiLock);
}
Forbid();
if(*Width)
{
if(Info -> Width)
*Left = Info -> Left;
else
*Left = WindowLeft + (WindowWidth - *Width) / 2;
}
else
{
if(DefWidth && !Info -> Width)
{
*Width = DefWidth;
*Left = WindowLeft + (WindowWidth - *Width) / 2;
}
else
{
if(Info -> Width)
{
*Width = Info -> Width;
*Left = Info -> Left;
}
else
{
/* *Width = WindowWidth / 2;*/
/* *Left = WindowLeft + WindowWidth / 4;*/
*Width = WindowWidth;
*Left = WindowLeft;
}
}
}
if(*Height)
{
if(Info -> Height)
*Top = Info -> Top;
else
*Top = WindowTop + (WindowHeight - *Height) / 2;
}
else
{
if(DefHeight && !Info -> Height)
{
*Height = DefHeight;
*Top = WindowTop + (WindowHeight - *Height) / 2;
}
else
{
if(Info -> Height)
{
*Height = Info -> Height;
*Top = Info -> Top;
}
else
{
/* *Height = WindowHeight / 2;*/
/* *Top = WindowTop + WindowHeight / 4;*/
*Height = WindowHeight;
*Top = WindowTop;
}
}
}
if(Info -> WindowFlags & WC_ALIGNSIDE)
*Left = WindowLeft + WindowWidth;
if(Info -> WindowFlags & WC_ALIGNBELOW)
*Top = WindowTop + WindowHeight;
if(Info -> WindowFlags & WC_ALIGNLEFT)
*Left = WindowLeft;
if(Info -> WindowFlags & WC_ALIGNTOP)
*Top = WindowTop;
if(Info -> WindowFlags & WC_ALIGNRIGHT)
*Left = WindowLeft + WindowWidth - *Width;
if(Info -> WindowFlags & WC_ALIGNBOTTOM)
*Top = WindowTop + WindowHeight - *Height;
if(Info -> WindowFlags & WC_EXPANDWIDTH)
*Width = WindowWidth;
if(Info -> WindowFlags & WC_EXPANDHEIGHT)
*Height = WindowHeight;
Permit();
}
/* GetBitMapDepth(struct BitMap *BitMap):
*
* Return the depth of a BitMap.
*/
LONG __regargs
GetBitMapDepth(struct BitMap *BitMap)
{
LONG Depth;
if(Kick30)
Depth = (LONG)GetBitMapAttr(BitMap,BMA_DEPTH);
else
Depth = BitMap -> Depth;
if(Depth > 8)
Depth = 8;
return(Depth);
}
/* GetDPI(ULONG Mode,ULONG *X_DPI,ULONG *Y_DPI):
*
* Get screen DPI resolution values.
*/
VOID __regargs
GetDPI(ULONG Mode,ULONG *X_DPI,ULONG *Y_DPI)
{
struct DisplayInfo DisplayInfo;
if(GetDisplayInfoData(NULL,(APTR)&DisplayInfo,sizeof(struct DisplayInfo),DTAG_DISP,Mode))
{
*X_DPI = (35 * 140) / DisplayInfo . PixelSpeed;
*Y_DPI = (*X_DPI * DisplayInfo . Resolution . x) / DisplayInfo . Resolution . y;
}
else
*X_DPI = *Y_DPI = 72;
}
/* AddProtection(STRPTR FileName,ULONG Mask):
*
* Set bits in the protection mask of a file.
*/
VOID __regargs
AddProtection(STRPTR Name,ULONG Mask)
{
struct FileInfoBlock *FileInfo;
if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
{
BPTR FileLock;
if(FileLock = Lock(Name,ACCESS_READ))
{
if(Examine(FileLock,FileInfo))
{
UnLock(FileLock);
SetProtection(Name,FileInfo -> fib_Protection | Mask);
}
else
UnLock(FileLock);
}
FreeDosObject(DOS_FIB,FileInfo);
}
}
/* GetPubScreenName(struct Screen *Screen,STRPTR Name):
*
* Get the name of a public screen.
*/
BYTE __regargs
GetPubScreenName(struct Screen *Screen,STRPTR Name)
{
struct List *PubScreenList;
struct PubScreenNode *ScreenNode;
PubScreenList = LockPubScreenList();
for(ScreenNode = (struct PubScreenNode *)PubScreenList -> lh_Head ; ScreenNode -> psn_Node . ln_Succ ; ScreenNode = (struct PubScreenNode *)ScreenNode -> psn_Node . ln_Succ)
{
if(ScreenNode -> psn_Screen == Screen)
{
strcpy(Name,ScreenNode -> psn_Node . ln_Name);
UnlockPubScreenList();
return(TRUE);
}
}
UnlockPubScreenList();
return(FALSE);
}
/* InitSinglePort(struct MsgPort *Port):
*
* Initialize a plain MsgPort (as created on the stack) for
* usage. Don't try this at home, kids!
*/
VOID __regargs
InitSinglePort(struct MsgPort *Port)
{
memset(Port,0,sizeof(struct MsgPort));
Port -> mp_Flags = PA_SIGNAL;
Port -> mp_SigBit = SIGB_SINGLE;
Port -> mp_SigTask = SysBase -> ThisTask;
NewList(&Port -> mp_MsgList);
}
/* GoodStream(BPTR Stream):
*
* Check to see whether the current input file
* is an interactive stream.
*/
BYTE __regargs
GoodStream(BPTR Stream)
{
if(!Stream)
{
struct Process *ThisProcess = (struct Process *)SysBase -> ThisTask;
Stream = ThisProcess -> pr_CIS;
}
if(Stream)
{
struct FileHandle *Handle = (struct FileHandle *)BADDR(Stream);
if(Handle -> fh_Type)
{
if(IsInteractive(Stream))
return(TRUE);
}
}
return(FALSE);
}
/* GetProgramIcon():
*
* Try to find the icon of the program.
*/
struct DiskObject *
GetProgramIcon()
{
struct DiskObject *Icon = NULL;
/* Run from Workbench? */
if(WBenchMsg)
{
/* Sanity check. */
if(WBenchMsg -> sm_ArgList)
{
/* Yet another sanity check. */
if(WBenchMsg -> sm_ArgList -> wa_Name)
{
/* Try to find the icon in the current directory. */
if(Icon = GetDiskObjectNew(WBenchMsg -> sm_ArgList -> wa_Name))
{
if(Icon -> do_Type != WBTOOL)
{
FreeDiskObject(Icon);
Icon = NULL;
}
}
if(!Icon)
{
BPTR NewLock;
/* Move to the directory the
* program was run from.
*/
if(NewLock = Lock("PROGDIR:",ACCESS_READ))
{
BPTR OldLock;
OldLock = CurrentDir(NewLock);
/* Try to fetch the icon, use the
* default name if necessary.
*/
if(Icon = GetDiskObjectNew(WBenchMsg -> sm_ArgList -> wa_Name))
{
if(Icon -> do_Type != WBTOOL)
{
FreeDiskObject(Icon);
Icon = NULL;
}
}
if(!Icon)
{
if(Icon = GetDiskObjectNew("term"))
{
if(Icon -> do_Type != WBTOOL)
{
FreeDiskObject(Icon);
Icon = NULL;
}
}
}
CurrentDir(OldLock);
UnLock(NewLock);
}
}
}
}
}
/* Still no success. */
if(!Icon)
{
/* Use the default names. */
if(Icon = GetDiskObjectNew("term"))
{
if(Icon -> do_Type != WBTOOL)
{
FreeDiskObject(Icon);
Icon = NULL;
}
}
if(!Icon)
{
if(Icon = GetDiskObjectNew("PROGDIR:term"))
{
if(Icon -> do_Type != WBTOOL)
{
FreeDiskObject(Icon);
Icon = NULL;
}
}
}
}
return(Icon);
}
/* GetPenIndex(LONG Pen):
*
* Get the table index corresponding to an on-screen
* text rendering pen.
*/
LONG __regargs
GetPenIndex(LONG Pen)
{
LONG i;
for(i = 0 ; i < 16 ; i++)
{
if(MappedPens[0][i] == Pen)
return(i);
}
}
/* GetScreenWidth(struct Window *Window):
*
* Query the current screen width.
*/
LONG __regargs
GetScreenWidth(struct Window *Window)
{
if(Window)
{
if(Window -> Width > ScreenWidth || Window -> LeftEdge < -Window -> WScreen -> LeftEdge || Window -> LeftEdge + Window -> WScreen -> LeftEdge + Window -> Width > ScreenWidth)
return(ScreenWidth);
else
return(Window -> Width - (Window -> BorderLeft + Window -> BorderRight));
}
else
return(ScreenWidth);
}
/* GetScreenHeight(struct Window *Window):
*
* Query the current screen height.
*/
LONG __regargs
GetScreenHeight(struct Window *Window)
{
if(Window)
{
if(Window -> Height > ScreenHeight || Window -> TopEdge < -Window -> WScreen -> TopEdge || Window -> TopEdge + Window -> WScreen -> TopEdge + Window -> Height > ScreenHeight)
return(ScreenHeight);
else
return(Window -> Height - (Window -> BorderTop + Window -> BorderBottom));
}
else
return(ScreenHeight);
}
/* GetLeft(struct Screen *Screen):
*
* Get the screen left edge.
*/
STATIC LONG __regargs
GetLeft(struct Screen *Screen)
{
if(Screen -> LeftEdge >= 0)
return(0);
else
return(-Screen -> LeftEdge);
}
/* GetScreenLeft(struct Window *Window):
*
* Query the current screen left edge.
*/
LONG __regargs
GetScreenLeft(struct Window *Window)
{
if(Window)
{
if(Window -> Width > ScreenWidth || Window -> LeftEdge < -Window -> WScreen -> LeftEdge || Window -> LeftEdge + Window -> WScreen -> LeftEdge + Window -> Width > ScreenWidth)
return(GetLeft(Window -> WScreen));
else
return(Window -> LeftEdge + Window -> BorderLeft);
}
else
return(GetLeft(DefaultPubScreen ? DefaultPubScreen : SharedScreen));
}
/* GetTop(struct Screen *Screen):
*
* Get the screen top edge.
*/
STATIC LONG __regargs
GetTop(struct Screen *Screen)
{
if(Screen -> TopEdge >= 0)
return(0);
else
return(-Screen -> TopEdge);
}
/* GetScreenTop(struct Window *Window):
*
* Query the current screen top edge.
*/
LONG __regargs
GetScreenTop(struct Window *Window)
{
if(Window)
{
if(Window -> Height > ScreenHeight || Window -> TopEdge < -Window -> WScreen -> TopEdge || Window -> TopEdge + Window -> WScreen -> TopEdge + Window -> Height > ScreenHeight)
return(GetTop(Window -> WScreen));
else
return(Window -> TopEdge + Window -> BorderTop);
}
else
return(GetTop(DefaultPubScreen ? DefaultPubScreen : SharedScreen));
}
/* OldGetAPen(struct RastPort *RPort):
*
* Query the current primary rendering colour (old style).
*/
ULONG
OldGetAPen(struct RastPort *RPort)
{
return((ULONG)RPort -> FgPen);
}
/* OldGetBPen(struct RastPort *RPort):
*
* Query the current seconary rendering colour (old style).
*/
ULONG
OldGetBPen(struct RastPort *RPort)
{
return((ULONG)RPort -> BgPen);
}
/* OldGetDrMd(struct RastPort *RPort):
*
* Query the current drawing mode (old style).
*/
ULONG
OldGetDrMd(struct RastPort *RPort)
{
return((ULONG)RPort -> DrawMode);
}
/* OldSetWrMsk(struct RastPort *RPort,ULONG Mask):
*
* Set the rendering plane mask (old style).
*/
ULONG
OldSetWrMsk(struct RastPort *RPort,ULONG Mask)
{
if(UseMasking)
RPort -> Mask = Mask;
return((ULONG)1);
}
/* NewGetAPen(struct RastPort *RPort):
*
* Query the current primary rendering colour (new style).
*/
ULONG
NewGetAPen(struct RastPort *RPort)
{
return(GetAPen(RPort));
}
/* NewGetBPen(struct RastPort *RPort):
*
* Query the current seconary rendering colour (new style).
*/
ULONG
NewGetBPen(struct RastPort *RPort)
{
return(GetBPen(RPort));
}
/* NewGetDrMd(struct RastPort *RPort):
*
* Query the current drawing mode (new style).
*/
ULONG
NewGetDrMd(struct RastPort *RPort)
{
return(GetDrMd(RPort));
}
/* NewSetWrMsk(struct RastPort *RPort,ULONG Mask):
*
* Set the rendering plane mask (new style).
*/
ULONG
NewSetWrMsk(struct RastPort *RPort,ULONG Mask)
{
if(UseMasking)
return(SetWriteMask(RPort,Mask));
else
return((ULONG)1);
}
/* SetWait(struct Window *Window):
*
* Set the busy wait mouse pointer.
*/
VOID __regargs
SetWait(struct Window *Window)
{
if(Kick30)
{
SetWindowPointer(Window,
WA_BusyPointer, TRUE,
WA_PointerDelay, TRUE,
TAG_DONE);
}
else
SetPointer(Window,Stopwatch,16,16,-6,0);
}
/* ClrWait(struct Window *Window):
*
* Remove the busy wait mouse pointer.
*/
VOID __regargs
ClrWait(struct Window *Window)
{
if(Kick30)
SetWindowPointer(Window,TAG_DONE);
else
ClearPointer(Window);
}
/* GetModeName(ULONG Mode):
*
* Get the name of a display mode.
*/
STRPTR __regargs
GetModeName(ULONG Mode)
{
STATIC UBYTE __far Buffer[DISPLAYNAMELEN + 1];
struct NameInfo NameInfo;
if(GetDisplayInfoData(NULL,(APTR)&NameInfo,sizeof(struct NameInfo),DTAG_NAME,Mode))
strcpy(Buffer,NameInfo . Name);
else
{
struct DimensionInfo DimensionInfo;
if(GetDisplayInfoData(NULL,(APTR)&DimensionInfo,sizeof(struct DimensionInfo),DTAG_DIMS,Mode))
{
STRPTR MonitorName;
switch(Mode & MONITOR_ID_MASK)
{
case NTSC_MONITOR_ID:
MonitorName = "NTSC: ";
break;
case PAL_MONITOR_ID:
MonitorName = "PAL: ";
break;
case VGA_MONITOR_ID:
MonitorName = "VGA: ";
break;
case A2024_MONITOR_ID:
MonitorName = "A2024: ";
break;
default:
MonitorName = "";
break;
}
SPrintf(Buffer,"%s%ld × %ld",MonitorName,DimensionInfo . TxtOScan . MaxX - DimensionInfo . TxtOScan . MinX + 1,DimensionInfo . TxtOScan . MaxY - DimensionInfo . TxtOScan . MinY + 1);
}
else
strcpy(Buffer,LocaleString(MSG_SCREENPANEL_UNKNOWN_TXT));
}
return(Buffer);
}
/* ModeOkay(ULONG ID):
*
* Checks whether a display mode ID will do for deep
* screen bitmaps.
*/
BYTE __regargs
ModeOkay(ULONG ID)
{
struct DimensionInfo DimensionInfo;
if(GetDisplayInfoData(NULL,(APTR)&DimensionInfo,sizeof(struct DimensionInfo),DTAG_DIMS,ID))
{
if(DimensionInfo . MaxDepth >= 4)
return(TRUE);
}
return(FALSE);
}
/* SetClipMenu(BYTE Mode):
*
* Enable/disable the copy/clear selection menu items.
*/
VOID __regargs
SetClipMenu(BYTE Mode)
{
if(Mode && RasterEnabled)
{
OnItem(MEN_COPY);
OnItem(MEN_CLEAR);
}
else
{
OffItem(MEN_COPY);
OffItem(MEN_CLEAR);
}
}
/* SetRedialMenu():
*
* Make the `redial' menu item available or make it
* unavailable.
*/
VOID
SetRedialMenu()
{
BYTE Mode;
if(DialList)
{
if(DialList -> lh_Head -> ln_Succ)
Mode = TRUE;
else
Mode = FALSE;
}
else
Mode = FALSE;
if(Mode && (DialItemsAvailable || Config -> MiscConfig -> ProtectiveMode))
OnItem(MEN_REDIAL);
else
OffItem(MEN_REDIAL);
}
/* SetDialMenu(BYTE Mode):
*
* Block or enable the dialing menu.
*/
VOID __regargs
SetDialMenu(BYTE Mode)
{
if(Window && Menu)
{
if(Mode || Config -> MiscConfig -> ProtectiveMode)
{
if(DialList)
{
if(DialList -> lh_Head -> ln_Succ)
OnItem(MEN_REDIAL);
else
OffItem(MEN_REDIAL);
}
else
OffItem(MEN_REDIAL);
OnItem(MEN_DIAL_NUMBER);
if(FirstDialMenu != -1)
OnItem(MEN_EXTRA_DIAL);
}
else
{
OffItem(MEN_REDIAL);
OffItem(MEN_DIAL_NUMBER);
if(FirstDialMenu != -1)
OffItem(MEN_EXTRA_DIAL);
}
DialItemsAvailable = Mode;
}
}
/* SetTransferMenu(BYTE Mode):
*
* Block or enable the transfer menu.
*/
VOID __regargs
SetTransferMenu(BYTE Mode)
{
if(Window && Menu)
{
BOOLEAN ValidDefault,
ValidASCIIDownload,
ValidASCIIUpload,
ValidTextDownload,
ValidTextUpload,
ValidBinaryDownload,
ValidBinaryUpload;
if(!Config -> TransferConfig -> DefaultLibrary[0] || !Mode)
ValidDefault = FALSE;
else
ValidDefault = TRUE;
switch(Config -> TransferConfig -> ASCIIUploadType)
{
case XFER_INTERNAL:
ValidASCIIUpload = TRUE;
break;
case XFER_DEFAULT:
ValidASCIIUpload = ValidDefault;
break;
case XFER_XPR:
case XFER_EXTERNALPROGRAM:
ValidASCIIUpload = Config -> TransferConfig -> ASCIIUploadLibrary[0];
break;
}
switch(Config -> TransferConfig -> ASCIIDownloadType)
{
case XFER_INTERNAL:
ValidASCIIDownload = TRUE;
break;
case XFER_DEFAULT:
ValidASCIIDownload = ValidDefault;
break;
case XFER_XPR:
case XFER_EXTERNALPROGRAM:
ValidASCIIDownload = Config -> TransferConfig -> ASCIIDownloadLibrary[0];
break;
}
switch(Config -> TransferConfig -> TextUploadType)
{
case XFER_DEFAULT:
ValidTextUpload = ValidDefault;
break;
case XFER_XPR:
case XFER_EXTERNALPROGRAM:
ValidTextUpload = Config -> TransferConfig -> TextUploadLibrary[0];
break;
}
switch(Config -> TransferConfig -> TextDownloadType)
{
case XFER_DEFAULT:
ValidTextDownload = ValidDefault;
break;
case XFER_XPR:
case XFER_EXTERNALPROGRAM:
ValidTextDownload = Config -> TransferConfig -> TextDownloadLibrary[0];
break;
}
switch(Config -> TransferConfig -> BinaryUploadType)
{
case XFER_DEFAULT:
ValidBinaryUpload = ValidDefault;
break;
case XFER_XPR:
case XFER_EXTERNALPROGRAM:
ValidBinaryUpload = Config -> TransferConfig -> BinaryUploadLibrary[0];
break;
}
switch(Config -> TransferConfig -> BinaryDownloadType)
{
case XFER_DEFAULT:
ValidBinaryDownload = ValidDefault;
break;
case XFER_XPR:
case XFER_EXTERNALPROGRAM:
ValidBinaryDownload = Config -> TransferConfig -> BinaryDownloadLibrary[0];
break;
}
if(ValidASCIIUpload)
OnItem(MEN_UPLOAD_ASCII);
else
OffItem(MEN_UPLOAD_ASCII);
if(ValidASCIIDownload)
OnItem(MEN_DOWNLOAD_ASCII);
else
OffItem(MEN_DOWNLOAD_ASCII);
if(ValidTextUpload)
{
OnItem(MEN_UPLOAD_TEXT);
OnItem(MEN_EDIT_AND_UPLOAD_TEXT);
}
else
{
OffItem(MEN_UPLOAD_TEXT);
OffItem(MEN_EDIT_AND_UPLOAD_TEXT);
}
if(ValidTextDownload)
OnItem(MEN_DOWNLOAD_TEXT);
else
OffItem(MEN_DOWNLOAD_TEXT);
if(ValidBinaryUpload)
OnItem(MEN_UPLOAD_BINARY);
else
OffItem(MEN_UPLOAD_BINARY);
if(ValidBinaryDownload)
OnItem(MEN_DOWNLOAD_BINARY);
else
OffItem(MEN_DOWNLOAD_BINARY);
if(ValidDefault)
OnItem(MEN_TRANSFER);
else
OffItem(MEN_TRANSFER);
}
}
/* SetRasterMenu(BYTE Mode):
*
* Block or enable the menu entries associated with
* functions to access the screen raster.
*/
VOID __regargs
SetRasterMenu(BYTE Mode)
{
if(Window && Menu)
{
if(Mode)
{
OnItem(MEN_SAVE_AS_TEXT);
OnItem(MEN_PRINT_SCREEN);
}
else
{
OffItem(MEN_SAVE_AS_TEXT);
OffItem(MEN_PRINT_SCREEN);
}
}
}
/* PickFont(struct Window *Window,STRPTR Name,WORD *Points,BYTE MonoSpaced):
*
* Pick a font using asl.library
*/
BYTE __regargs
PickFont(struct Window *Window,STRPTR Name,WORD *Points,BYTE MonoSpaced)
{
struct FontRequester *Requester;
struct TagItem DimensionTags[5];
BYTE Result = FALSE;
if(Requester = (struct FontRequester *)AllocAslRequestTags(ASL_FontRequest,
ASL_Window, Window,
ASLFO_InitialFrontPen, DrawInfo -> dri_Pens[TEXTPEN],
ASLFO_InitialBackPen, DrawInfo -> dri_Pens[BACKGROUNDPEN],
MonoSpaced ? ASL_FuncFlags : TAG_IGNORE, FONF_FIXEDWIDTH,
TAG_MORE,GetDimensionTags(NULL,DimensionTags)))
{
if(AslRequestTags(Requester,
ASL_FontName, Name,
ASL_FontHeight, *Points,
TAG_DONE))
{
PutDimensionTags(NULL,Requester -> fo_LeftEdge,Requester -> fo_TopEdge,Requester -> fo_Width,Requester -> fo_Height);
strcpy(Name,Requester -> fo_Attr . ta_Name);
*Points = Requester -> fo_Attr . ta_YSize;
Result = TRUE;
}
FreeAslRequest(Requester);
}
return(Result);
}
/* ExtractString():
*
* Extracts a string from a list separated by `|' characters.
*/
STRPTR __regargs
ExtractString(STRPTR String,STRPTR Destination,BYTE ReturnEnd)
{
STRPTR OldString;
if(ReturnEnd)
OldString = NULL;
else
OldString = String;
while(*String)
{
if(*String == '|')
{
*Destination = 0;
String++;
if(*String)
return(String);
else
return(OldString);
}
else
*Destination++ = *String++;
}
*Destination = 0;
return(OldString);
}
/* GetListSize(struct List *List):
*
* Determine the number of entries in a list.
*/
LONG __regargs
GetListSize(struct List *List)
{
struct Node *Node = List -> lh_Head;
LONG i = 0;
while(Node -> ln_Succ)
{
i++;
Node = Node -> ln_Succ;
}
return(i);
}
/* GetListNode(LONG Offset,struct List *List):
*
* Return the n-th Node entry in a standard exec list.
*/
struct Node * __regargs
GetListNode(LONG Offset,struct List *List)
{
struct Node *Node;
LONG i;
Node = List -> lh_Head;
for(i = 0 ; i < Offset ; i++)
{
if(!Node -> ln_Succ -> ln_Succ)
return(NULL);
Node = Node -> ln_Succ;
}
return(Node);
}
/* CreateNode(STRPTR Name):
*
* Put a name string into a list node.
*/
struct Node * __regargs
CreateNode(STRPTR Name)
{
struct Node *Node;
if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + strlen(Name) + 1,MEMF_ANY | MEMF_PUBLIC))
{
Node -> ln_Name = (STRPTR)(Node + 1);
strcpy(Node -> ln_Name,Name);
}
return(Node);
}
/* FreeNode(struct Node *Node):
*
* Remove and deallocate a node.
*/
VOID __regargs
FreeNode(struct Node *Node)
{
Remove(Node);
FreeVecPooled(Node);
}
/* FreeList(struct List *List):
*
* Remove all nodes from the list
* and free them on the way.
*/
VOID __regargs
FreeList(struct List *List)
{
struct Node *Node,*NextNode;
Node = List -> lh_Head;
while(NextNode = Node -> ln_Succ)
{
FreeNode(Node);
Node = NextNode;
}
}
/* GetNodeOffset(struct Node *Node,struct List *List):
*
* Scan a list for a certain node and return
* its position.
*/
LONG __regargs
GetNodeOffset(struct Node *Node,struct List *List)
{
struct Node *ListNode;
LONG Offset = 0;
ListNode = List -> lh_Head;
while(ListNode -> ln_Succ)
{
if(Node == ListNode)
return(Offset);
else
{
Offset++;
ListNode = ListNode -> ln_Succ;
}
}
return(~0);
}
/* MoveList(struct List *From,struct List *To):
*
* Move the contents of a list to a different list.
*/
VOID __regargs
MoveList(struct List *From,struct List *To)
{
struct Node *Node,*NextNode;
Node = From -> lh_Head;
while(NextNode = Node -> ln_Succ)
{
Remove(Node);
AddTail(To,Node);
Node = NextNode;
}
}
/* LogAction(STRPTR String,...):
*
* Write an action to the default log file.
*/
VOID __stdargs
LogAction(STRPTR String,...)
{
if(Config -> CaptureConfig -> LogActions && Config -> CaptureConfig -> LogFileName[0])
{
UBYTE DummyBuffer[512];
BPTR File;
va_list VarArgs;
/* Build a valid string. */
va_start(VarArgs,String);
VSPrintf(DummyBuffer,String,VarArgs);
va_end(VarArgs);
/* Does the log file already exist? */
if(GetFileSize(Config -> CaptureConfig -> LogFileName))
{
/* It does, let's append the data. */
if(File = Open(Config -> CaptureConfig -> LogFileName,MODE_READWRITE))
{
if(Seek(File,0,OFFSET_END) == -1)
{
Close(File);
File = NULL;
}
}
}
else
{
/* Create a new file. */
if(File = Open(Config -> CaptureConfig -> LogFileName,MODE_NEWFILE))
FPrintf(File,LocaleString(MSG_TERMAUX_DATE_TIME_ACTION_TXT));
}
/* The file is open, build the date/time string and
* write the log action.
*/
if(File)
{
UBYTE DateBuffer[40],
TimeBuffer[40];
struct DateTime DateTime;
DateStamp(&DateTime . dat_Stamp);
DateTime . dat_Format = FORMAT_DOS;
DateTime . dat_Flags = NULL;
DateTime . dat_StrDay = NULL;
DateTime . dat_StrDate = DateBuffer;
DateTime . dat_StrTime = TimeBuffer;
if(DateToStr(&DateTime))
{
StripSpaces(TimeBuffer);
FPrintf(File,"%-9s %8s %s\n",DateBuffer,TimeBuffer,DummyBuffer);
}
/* Done! */
Close(File);
}
}
}
/* FlushMsg(struct Window *Window):
*
* Cancel all pending messages of a window.
*/
VOID __regargs
FlushMsg(struct Window *Window)
{
struct IntuiMessage *Massage;
while(Massage = (struct IntuiMessage *)GetMsg(Window -> UserPort))
ReplyMsg(&Massage -> ExecMessage);
}
/* GetString(STRPTR Prompt,STRPTR Buffer):
*
* Get a string from the user, very much the same as xpr_gets,
* but also including the `Load File' gadget.
*/
BYTE __regargs
GetString(BYTE LoadGadget,BYTE Password,WORD MaxChars,STRPTR Prompt,STRPTR Buffer)
{
enum { GAD_OK=1,GAD_CANCEL,GAD_STRING };
struct LayoutHandle *Handle;
BYTE Success = FALSE;
UBYTE LocalBuffer[256];
if(!MaxChars)
MaxChars = 255;
if(MaxChars > 255)
{
CopyMem(Buffer,LocalBuffer,255);
LocalBuffer[255] = 0;
MaxChars = 255;
}
else
strcpy(LocalBuffer,Buffer);
if(!Prompt)
Prompt = LocaleString(MSG_TERMXPR_INPUT_REQUIRED_TXT);
if(Handle = LT_CreateHandleTags(Window -> WScreen,
LH_LocaleHook, &LocaleHook,
TAG_DONE))
{
struct Window *PanelWindow;
LT_New(Handle,
LA_Type, VERTICAL_KIND,
TAG_DONE);
{
LT_New(Handle,
LA_Type, VERTICAL_KIND,
LA_LabelText, Prompt,
TAG_DONE);
{
if(Password)
{
LT_New(Handle,
LA_Type, PASSWORD_KIND,
LA_STRPTR, LocalBuffer,
LA_ID, GAD_STRING,
LA_Chars, 40,
GTST_MaxChars, MaxChars,
TAG_DONE);
}
else
{
LT_New(Handle,
LA_Type, STRING_KIND,
LA_STRPTR, LocalBuffer,
LA_ID, GAD_STRING,
LA_Chars, 60,
LAST_Picker, LoadGadget,
TAG_DONE);
}
LT_EndGroup(Handle);
}
LT_New(Handle,
LA_Type,VERTICAL_KIND,
TAG_DONE);
{
LT_New(Handle,
LA_Type, XBAR_KIND,
LAXB_FullSize, TRUE,
TAG_DONE);
LT_EndGroup(Handle);
}
LT_New(Handle,LA_Type,HORIZONTAL_KIND,
LAGR_SameSize, TRUE,
LAGR_Spread, TRUE,
TAG_DONE);
{
LT_New(Handle,
LA_Type, BUTTON_KIND,
LA_LabelID, MSG_TERMXPR_OKAY_GAD,
LA_ID, GAD_OK,
LABT_ReturnKey, TRUE,
LABT_ExtraFat, TRUE,
TAG_DONE);
LT_New(Handle,
LA_Type, BUTTON_KIND,
LA_LabelID, MSG_GLOBAL_CANCEL_GAD,
LA_ID, GAD_CANCEL,
LABT_EscKey, TRUE,
LABT_ExtraFat, TRUE,
TAG_DONE);
LT_EndGroup(Handle);
}
}
if(PanelWindow = LT_Layout(Handle,LocaleString(MSG_GLOBAL_ENTER_TEXT_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
LAWN_HelpHook, &GuideHook,
LAWN_Parent, Window,
WA_DepthGadget, TRUE,
WA_CloseGadget, TRUE,
WA_DragBar, TRUE,
WA_RMBTrap, TRUE,
WA_Activate, TRUE,
TAG_DONE))
{
struct IntuiMessage *Message;
BOOLEAN Done = FALSE;
ULONG MsgClass,
MsgQualifier;
UWORD MsgCode;
struct Gadget *MsgGadget;
LT_Activate(Handle,GAD_STRING);
PushWindow(PanelWindow);
LT_ShowWindow(Handle,TRUE);
do
{
if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
break;
while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort))
{
MsgClass = Message -> Class;
MsgQualifier = Message -> Qualifier;
MsgCode = Message -> Code;
MsgGadget = (struct Gadget *)Message -> IAddress;
GT_ReplyIMsg(Message);
LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
if(MsgClass == IDCMP_CLOSEWINDOW)
Done = TRUE;
if(MsgClass == IDCMP_GADGETUP)
{
switch(MsgGadget -> GadgetID)
{
case GAD_STRING:
if(MsgCode == '\r')
{
strcpy(Buffer,LocalBuffer);
Success = Done = TRUE;
LT_PressButton(Handle,GAD_OK);
}
break;
case GAD_OK:
LT_UpdateStrings(Handle);
strcpy(Buffer,LocalBuffer);
Success = Done = TRUE;
break;
case GAD_CANCEL:
Done = TRUE;
break;
}
}
if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadget -> GadgetID == GAD_STRING)
{
UBYTE DummyBuffer[MAX_FILENAME_LENGTH],
*DummyChar;
struct FileRequester *FileRequest;
LT_LockWindow(PanelWindow);
SplitFileName(LocalBuffer,&DummyChar,DummyBuffer);
if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_TERMAUX_LOAD_FILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
{
LT_SetAttributes(Handle,GAD_STRING,GTST_String,DummyBuffer,TAG_DONE);
FreeAslRequest(FileRequest);
}
LT_UnlockWindow(PanelWindow);
}
}
}
while(!Done);
PopWindow();
}
LT_DeleteHandle(Handle);
}
return(Success);
}
/* WakeUp(struct Window *Window,WORD Sound):
*
* Pop a window to the front and alert the user.
*/
VOID __regargs
WakeUp(struct Window *Window,WORD Sound)
{
if(Window)
{
if(Config -> MiscConfig -> AlertMode == ALERT_SCREEN || Config -> MiscConfig -> AlertMode == ALERT_BEEP_SCREEN)
{
if(Window -> WScreen -> LeftEdge > 0)
{
if(Window -> WScreen -> TopEdge > 0)
MoveScreen(Window -> WScreen,-Window -> WScreen -> LeftEdge,-Window -> WScreen -> TopEdge);
else
MoveScreen(Window -> WScreen,-Window -> WScreen -> LeftEdge,0);
}
else
{
if(Window -> WScreen -> TopEdge > 0)
MoveScreen(Window -> WScreen,0,-Window -> WScreen -> TopEdge);
}
WindowToFront(Window);
ScreenToFront(Window -> WScreen);
}
}
if(Sound != SOUND_BELL || Config -> MiscConfig -> AlertMode == ALERT_BEEP || Config -> MiscConfig -> AlertMode == ALERT_BEEP_SCREEN)
SoundPlay(Sound);
}
/* TaskDestructor(struct DataMsg *Item):
*
* Msg destructor for the routines below.
*/
STATIC VOID __stdargs
TaskDestructor(struct DataMsg *Item)
{
Signal((struct Process *)Item -> Data,SIGBREAKF_CTRL_F);
}
/* AmigaDOSBackgroundServer(VOID):
*
* Background process to handle tool execution.
*/
STATIC VOID __saveds
AmigaDOSBackgroundServer(VOID)
{
BPTR OldCOS,
NewCOS = NULL;
struct DataMsg Msg;
STRPTR Command;
struct Process *Me;
/* Look who we are. */
Me = (struct Process *)SysBase -> ThisTask;
Command = Me -> pr_Task . tc_UserData;
/* Create console output stream, will be closed automagically on exit. */
if(!Me -> pr_COS && Me -> pr_ConsoleTask)
{
if(NewCOS = Open("*",MODE_NEWFILE))
{
OldCOS = Me -> pr_COS;
Me -> pr_COS = NewCOS;
}
}
SystemTags(Command,
SYS_UserShell, TRUE,
TAG_DONE);
FreeVecPooled(Command);
Forbid();
InitMsgItem(&Msg,TaskDestructor);
Msg . Type = DATAMSGTYPE_COMMANDDONE;
Msg . Data = (UBYTE *)Me;
ClrSignal(SIGBREAKF_CTRL_F);
PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
Wait(SIGBREAKF_CTRL_F);
if(NewCOS)
{
Me -> pr_COS = OldCOS;
Close(NewCOS);
}
}
/* SendAmigaDOSCommand(STRPTR Name):
*
* Let the current default Shell execute an AmigaDOS
* command. Block until the command has returned.
*/
VOID __regargs
SendAmigaDOSCommand(STRPTR Name)
{
STRPTR NewName;
if(NewName = (STRPTR)AllocVecPooled(strlen(Name) + 1 + 256,MEMF_ANY))
{
struct Process *NewProcess;
BPTR Stream;
STRPTR NewWindowName;
strcpy(NewName,Name);
NewWindowName = NewName + strlen(NewName) + 1;
BlockWindows();
SetQueueDiscard(SpecialQueue,FALSE);
/* Open the output file. */
if(WindowName[0])
{
UBYTE LocalName[MAXPUBSCREENNAME + 1];
if(Window)
{
if(!GetPubScreenName(Window -> WScreen,LocalName))
LocalName[0] = 0;
}
if(LocalName[0])
{
SPrintf(NewWindowName,WindowName,LocalName);
Stream = Open(NewWindowName,MODE_NEWFILE);
}
else
Stream = Open(WindowName,MODE_NEWFILE);
}
else
Stream = NULL;
Forbid();
if(Stream)
{
if(GoodStream(Stream))
{
struct FileHandle *Handle = (struct FileHandle *)BADDR(Stream);
NewProcess = (struct Process *)CreateNewProcTags(
NP_Entry, AmigaDOSBackgroundServer,
NP_Name, "term AmigaDOS Background Process",
NP_Input, Stream,
NP_Output, NULL,
NP_Cli, TRUE,
NP_ConsoleTask, Handle -> fh_Type,
NP_StackSize, 16384,
TAG_END);
}
else
{
NewProcess = (struct Process *)CreateNewProcTags(
NP_Entry, AmigaDOSBackgroundServer,
NP_Name, "term AmigaDOS Background Process",
NP_Output, Stream,
NP_Cli, TRUE,
NP_ConsoleTask, NULL,
NP_StackSize, 16384,
TAG_END);
}
}
else
{
NewProcess = (struct Process *)CreateNewProcTags(
NP_Entry, AmigaDOSBackgroundServer,
NP_Name, "term AmigaDOS Background Process",
NP_Cli, TRUE,
NP_ConsoleTask, NULL,
NP_StackSize, 16384,
TAG_END);
}
/* Did we succeed in creating the process? */
if(NewProcess)
{
CantQuit++;
NewProcess -> pr_Task . tc_UserData = NewName;
Permit();
}
else
{
Permit();
if(Stream)
Close(Stream);
FreeVecPooled(NewName);
BumpWindow(Window);
ReleaseWindows();
}
}
}
/* RexxBackgroundServer():
*
* The background process to handle the rexx
* massaging.
*/
STATIC VOID __saveds
RexxBackgroundServer(VOID)
{
struct MsgPort *RexxPort;
BPTR OldCOS,
NewCOS = NULL;
struct DataMsg Msg;
STRPTR Command;
struct Process *Me;
/* Look who we are. */
Me = (struct Process *)SysBase -> ThisTask;
Command = Me -> pr_Task . tc_UserData;
/* Create console output stream, will be closed automagically on exit. */
if(!Me -> pr_COS && Me -> pr_ConsoleTask)
{
if(NewCOS = Open("*",MODE_NEWFILE))
{
OldCOS = Me -> pr_COS;
Me -> pr_COS = NewCOS;
}
}
if(RexxPort = FindPort(RXSDIR))
{
struct MsgPort __aligned ReplyPort;
struct RexxMsg *RexxMsg;
InitSinglePort(&ReplyPort);
if(RexxMsg = CreateRexxMsg(&ReplyPort,"term",RexxPortName))
{
if(RexxMsg -> rm_Args[0] = CreateArgstring(Command,strlen(Command)))
{
RexxMsg -> rm_Action = RXCOMM;
Forbid();
ClrSignal(SIGF_SINGLE);
PutMsg(RexxPort,(struct Message *)RexxMsg);
WaitPort(&ReplyPort);
GetMsg(&ReplyPort);
Permit();
/* This doesn't look too
* good, does it?
*/
if(RexxMsg -> rm_Result1 && Me -> pr_COS)
Printf(LocaleString(MSG_TERMAUX_COMMAND_HAS_TERMINATED_TXT),Command,RexxMsg -> rm_Result1,RexxMsg -> rm_Result2);
DeleteArgstring(RexxMsg -> rm_Args[0]);
}
DeleteRexxMsg(RexxMsg);
}
}
FreeVecPooled(Command);
Forbid();
InitMsgItem(&Msg,TaskDestructor);
Msg . Type = DATAMSGTYPE_COMMANDDONE;
Msg . Data = (UBYTE *)Me;
ClrSignal(SIGBREAKF_CTRL_F);
PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
Wait(SIGBREAKF_CTRL_F);
if(NewCOS)
{
Me -> pr_COS = OldCOS;
Close(NewCOS);
}
}
/* SendARexxCommand(STRPTR Name,BOOL QueueIt):
*
* Let the ARexx server execute a command (or a script
* file if necessary) and block until the command
* has returned.
*/
VOID __regargs
SendARexxCommand(STRPTR Name,BOOL QueueIt)
{
STRPTR NewName;
if(QueueIt)
{
ObtainSemaphore(&ARexxQueueSemaphore);
if(ARexxRunning)
{
struct Node *Node;
if(Node = CreateNode(Name))
AddTail(&ARexxQueue,Node);
ReleaseSemaphore(&ARexxQueueSemaphore);
return;
}
}
if(NewName = (STRPTR)AllocVecPooled(strlen(Name) + 1 + 256,MEMF_ANY))
{
struct Process *NewProcess;
BPTR Stream;
STRPTR NewWindowName;
strcpy(NewName,Name);
NewWindowName = NewName + strlen(NewName) + 1;
BlockWindows();
SetQueueDiscard(SpecialQueue,FALSE);
/* Open the output file. */
if(WindowName[0])
{
UBYTE LocalName[MAXPUBSCREENNAME + 1];
if(Window)
{
if(!GetPubScreenName(Window -> WScreen,LocalName))
LocalName[0] = 0;
}
if(LocalName[0])
{
SPrintf(NewWindowName,WindowName,LocalName);
Stream = Open(NewWindowName,MODE_NEWFILE);
}
else
Stream = Open(WindowName,MODE_NEWFILE);
}
else
Stream = NULL;
Forbid();
/* Create the background process which will
* handle all the messy rexx message sending
* for us.
*/
if(Stream)
{
if(GoodStream(Stream))
{
struct FileHandle *Handle = (struct FileHandle *)BADDR(Stream);
NewProcess = (struct Process *)CreateNewProcTags(
NP_Entry, RexxBackgroundServer,
NP_Name, "term ARexx Background Process",
NP_Input, Stream,
NP_Output, NULL,
NP_Cli, TRUE,
NP_ConsoleTask, Handle -> fh_Type,
NP_StackSize, 16384,
TAG_END);
}
else
{
NewProcess = (struct Process *)CreateNewProcTags(
NP_Entry, RexxBackgroundServer,
NP_Name, "term ARexx Background Process",
NP_Output, Stream,
NP_Cli, TRUE,
NP_ConsoleTask, NULL,
NP_StackSize, 16384,
TAG_END);
}
}
else
{
NewProcess = (struct Process *)CreateNewProcTags(
NP_Entry, RexxBackgroundServer,
NP_Name, "term ARexx Background Process",
NP_Cli, TRUE,
NP_ConsoleTask, NULL,
NP_StackSize, 16384,
TAG_END);
}
/* Did we succeed in creating the process? */
if(NewProcess)
{
CantQuit++;
NewProcess -> pr_Task . tc_UserData = NewName;
Permit();
if(QueueIt)
ARexxRunning = TRUE;
}
else
{
Permit();
if(Stream)
Close(Stream);
FreeVecPooled(NewName);
BumpWindow(Window);
ReleaseWindows();
}
}
if(QueueIt)
ReleaseSemaphore(&ARexxQueueSemaphore);
}
/* BlockWindows():
*
* Block the main window and the status window (i.e. disable
* the menu and attach a wait pointer).
*/
VOID
BlockWindows()
{
if(!(BlockNestCount++))
{
LT_LockWindow(Window);
LT_LockWindow(StatusWindow);
LT_LockWindow(FastWindow);
WeAreBlocking = TRUE;
SetQueueDiscard(SpecialQueue,TRUE);
GhostCursor();
}
}
/* ReleaseWindows():
*
* Reenable the menus and clear the wait pointer.
*/
VOID
ReleaseWindows()
{
if(BlockNestCount == 1)
{
LT_UnlockWindow(Window);
LT_UnlockWindow(StatusWindow);
LT_UnlockWindow(FastWindow);
WeAreBlocking = FALSE;
SetQueueDiscard(SpecialQueue,FALSE);
if(Window)
{
Forbid();
if(Window -> Flags & WFLG_WINDOWACTIVE)
NormalCursor();
Permit();
}
}
if(BlockNestCount)
BlockNestCount--;
}
/* LineRead(BPTR File,STRPTR Buffer,LONG MaxChars):
*
* Read a few bytes from a file (à la gets).
*/
LONG __regargs
LineRead(BPTR File,STRPTR Buffer,LONG MaxChars)
{
STATIC UBYTE __far Data[1024];
STATIC LONG ReadIndex = 0,
ReadLen = 0;
if(File)
{
LONG BytesRead = 0,i;
for(i = 0 ; i < MaxChars ; i++)
{
if(ReadIndex >= ReadLen)
{
ReadLen = Read(File,Data,1024);
ReadIndex = 0;
if(ReadLen <= 0)
{
Buffer[i] = 0;
return(BytesRead);
}
}
BytesRead++;
if((Buffer[i] = Data[ReadIndex++]) == '\n')
{
Buffer[i + 1] = 0;
return(BytesRead);
}
}
return(BytesRead);
}
else
ReadIndex = ReadLen = 0;
}
/* GetBaudRate(STRPTR Buffer):
*
* Calculate the baud rate contained in a connect string.
*/
LONG __regargs
GetBaudRate(STRPTR Buffer)
{
LONG Rate,i,j;
for(i = j = 0 ; i < strlen(Buffer) ; i++)
{
if(Buffer[i] == ' ')
continue;
else
{
if(Buffer[i] >= '0' && Buffer[i] <= '9')
SharedBuffer[j++] = Buffer[i];
else
break;
}
}
SharedBuffer[j] = 0;
if(StrToLong(SharedBuffer,&Rate) > 0)
{
if(Rate > 0)
return(Rate);
}
return(0);
}
/* LookForIt(struct MenuItem *Item,ULONG ID):
*
* Auxilary routine for FindThisItem(), scans
* menu item and sub item lists.
*/
STATIC struct MenuItem * __inline
LookForIt(struct MenuItem *Item,ULONG ID)
{
while(Item)
{
if((ULONG)GTMENUITEM_USERDATA(Item) == ID)
return(Item);
else
{
if(Item -> SubItem)
{
register struct MenuItem *TheItem;
if(TheItem = LookForIt(Item -> SubItem,ID))
return(TheItem);
}
Item = Item -> NextItem;
}
}
return(NULL);
}
/* FindThisItem(struct Menu *FirstMenu,ULONG MenuID):
*
* Scan a menu for a menuitem associated with a
* menu ID.
*/
struct MenuItem * __regargs
FindThisItem(struct Menu *FirstMenu,ULONG MenuID)
{
if(TypeOfMem(FirstMenu))
{
struct MenuItem *Item;
while(FirstMenu)
{
if(Item = LookForIt(FirstMenu -> FirstItem,MenuID))
return(Item);
else
FirstMenu = FirstMenu -> NextMenu;
}
}
return(NULL);
}
struct Menu * __regargs
FindThisMenu(struct Menu *FirstMenu,ULONG MenuID)
{
if(TypeOfMem(FirstMenu))
{
while(FirstMenu)
{
if(GTMENU_USERDATA(FirstMenu) == (APTR)MenuID)
return(FirstMenu);
else
FirstMenu = FirstMenu -> NextMenu;
}
}
return(NULL);
}
/* GetItem(ULONG MenuID):
*
* Get the checkmark state of a menu item.
*/
BYTE __regargs
GetItem(ULONG MenuID)
{
if(Menu)
{
struct MenuItem *Item;
if(Item = FindThisItem(Menu,MenuID))
{
if(Item -> Flags & CHECKED)
return(TRUE);
}
}
return(FALSE);
}
/* SetItem(ULONG MenuID,BYTE Mode):
*
* Clear or set the checkmark or state of a menu item.
*/
VOID __regargs
SetItem(ULONG MenuID,BYTE Mode)
{
/* Is the global pull-down menu available? */
if(Menu)
{
struct MenuItem *Item;
struct Menu *ThisMenu;
if(ThisMenu = FindThisMenu(Menu,MenuID))
{
/* Remove the menu from the windows. */
if(Window)
ClearMenuStrip(Window);
if(StatusWindow)
ClearMenuStrip(StatusWindow);
if(FastWindow)
ClearMenuStrip(FastWindow);
switch(Mode)
{
case SETITEM_ON:
ThisMenu -> Flags |= MENUENABLED;
break;
case SETITEM_OFF:
ThisMenu -> Flags &= ~MENUENABLED;
break;
}
/* Reattach the menu to the windows. */
if(Window)
ResetMenuStrip(Window,Menu);
if(StatusWindow)
ResetMenuStrip(StatusWindow,Menu);
if(FastWindow)
ResetMenuStrip(FastWindow,Menu);
return;
}
/* Try to find the menu item and change
* the state of the checkmark.
*/
if(Item = FindThisItem(Menu,MenuID))
{
/* Remove the menu from the windows. */
if(Window)
ClearMenuStrip(Window);
if(StatusWindow)
ClearMenuStrip(StatusWindow);
if(FastWindow)
ClearMenuStrip(FastWindow);
switch(Mode)
{
case SETITEM_SETCHECK:
Item -> Flags |= CHECKED;
break;
case SETITEM_CLRCHECK:
Item -> Flags &= ~CHECKED;
break;
case SETITEM_ON:
Item -> Flags |= ITEMENABLED;
break;
case SETITEM_OFF:
Item -> Flags &= ~ITEMENABLED;
break;
}
/* Reattach the menu to the windows. */
if(Window)
ResetMenuStrip(Window,Menu);
if(StatusWindow)
ResetMenuStrip(StatusWindow,Menu);
if(FastWindow)
ResetMenuStrip(FastWindow,Menu);
}
}
}
/* GetFileSize(STRPTR Name):
*
* Simple routine to return the size of a file in
* bytes.
*/
LONG __regargs
GetFileSize(STRPTR Name)
{
struct FileInfoBlock *FileInfo;
LONG FileSize = 0;
if(FileInfo = (struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_DONE))
{
BPTR FileLock;
if(FileLock = Lock(Name,ACCESS_READ))
{
if(Examine(FileLock,FileInfo))
{
if(FileInfo -> fib_DirEntryType < 0)
FileSize = FileInfo -> fib_Size;
}
UnLock(FileLock);
}
FreeDosObject(DOS_FIB,FileInfo);
}
return(FileSize);
}
/* PutDimensionTags(struct Window *Reference,LONG Left,LONG Top,LONG Width,LONG Height):
*
* Put back the default values for the requesters to open.
*/
VOID __regargs
PutDimensionTags(struct Window *Reference,LONG Left,LONG Top,LONG Width,LONG Height)
{
if(Config -> MiscConfig -> RequesterMode != REQUESTERMODE_IGNORE && (!Config -> MiscConfig -> RequesterWidth || !Config -> MiscConfig -> RequesterHeight))
{
if(!Reference)
Reference = Window;
Config -> MiscConfig -> RequesterLeft = Left - Reference -> LeftEdge;
Config -> MiscConfig -> RequesterTop = Top - Reference -> TopEdge;
Config -> MiscConfig -> RequesterWidth = Width;
Config -> MiscConfig -> RequesterHeight = Height;
}
}
/* GetDimensionTags(struct Window *Reference,struct TagItem *Tags):
*
* Fills an array of tagitems with the dimensions of an asl requester
* to be opened.
*/
struct TagItem * __regargs
GetDimensionTags(struct Window *Reference,struct TagItem *Tags)
{
if(Config -> MiscConfig -> RequesterMode == REQUESTERMODE_IGNORE || !Config -> MiscConfig -> RequesterWidth || !Config -> MiscConfig -> RequesterHeight)
{
STATIC ULONG Done = TAG_DONE;
return((struct TagItem *)&Done);
}
else
{
LONG Left,Top,Width,Height;
if(!Reference)
Reference = Window;
if(Config -> MiscConfig -> RequesterMode == REQUESTERMODE_CENTRE)
{
Left = Reference -> LeftEdge + (Reference -> Width - Config -> MiscConfig -> RequesterWidth) / 2;
Top = Reference -> TopEdge + (Reference -> Height - Config -> MiscConfig -> RequesterHeight) / 2;
}
else
{
Left = Config -> MiscConfig -> RequesterLeft + Reference -> LeftEdge;
Top = Config -> MiscConfig -> RequesterTop + Reference -> TopEdge;
}
Width = Config -> MiscConfig -> RequesterWidth;
Height = Config -> MiscConfig -> RequesterHeight;
Tags[0] . ti_Tag = ASL_LeftEdge;
Tags[0] . ti_Data = Left;
Tags[1] . ti_Tag = ASL_TopEdge;
Tags[1] . ti_Data = Top;
Tags[2] . ti_Tag = ASL_Width;
Tags[2] . ti_Data = Width;
Tags[3] . ti_Tag = ASL_Height;
Tags[3] . ti_Data = Height;
Tags[4] . ti_Data = TAG_DONE;
return(Tags);
}
}
/* GetFile(STRPTR Title,STRPTR Directory,STRPTR Name,STRPTR Buffer,STRPTR Pattern,BYTE SaveFlag,BYTE MultiSelect):
*
* Call the asl.library file requester to select a single or
* a couple of files.
*/
struct FileRequester * __regargs
GetFile(struct Window *Parent,STRPTR Title,STRPTR Directory,STRPTR Name,STRPTR Buffer,STRPTR Pattern,BYTE SaveFlag,BYTE MultiSelect,BYTE DirsOnly,STRPTR OKText,BYTE AskWrite)
{
STATIC UBYTE __far DirBuffer[MAX_FILENAME_LENGTH],
PatternBuffer[60];
struct FileRequester *AslFileRequest;
BYTE Result = FALSE,
DefaultPattern = FALSE;
LONG Flags,ExtFlags = 0;
WORD i,j;
UBYTE OtherTitle[60];
struct TagItem DimensionTags[5];
if(!Config -> MiscConfig -> ProtectiveMode)
AskWrite = FALSE;
if(!Parent)
Parent = Window;
for(i = j = 0 ; i < strlen(Title) ; i++)
{
if(Title[i] != '_')
OtherTitle[j++] = Title[i];
}
OtherTitle[j] = 0;
Title = OtherTitle;
if(DirsOnly)
{
ExtFlags |= FIL1F_NOFILES;
if(Pattern)
ExtFlags |= FIL1F_MATCHDIRS;
}
/* Empty directory string? Revert to the last directory
* name.
*/
Forbid();
if(!Directory[0])
{
if(!DirBuffer[0])
{
UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
if(!GetCurrentDirName(LocalBuffer,MAX_FILENAME_LENGTH))
LocalBuffer[0] = 0;
if(!DirBuffer[0])
strcpy(DirBuffer,LocalBuffer);
}
Directory = DirBuffer;
}
/* If a wildcard pattern is required, add a gadget
* to display it.
*/
if(Pattern)
{
Flags = FILF_PATGAD;
if(!Pattern[0])
{
DefaultPattern = TRUE;
if(PatternBuffer[0])
Pattern = PatternBuffer;
else
Pattern = "#?";
}
else
{
if(!Stricmp(Pattern,"#?") || !Stricmp(Pattern,PatternBuffer))
{
DefaultPattern = TRUE;
Pattern = PatternBuffer;
}
}
}
else
{
Flags = 0;
Pattern = "#?";
}
Permit();
/* Set the save flag if we are about to save something. */
if(SaveFlag)
Flags |= FILF_SAVE;
/* Set the multiselect bit if multiple files are
* to be selected (e.g. for batch file upload).
*/
if(MultiSelect)
Flags |= FILF_MULTISELECT;
/* Provide a standard `Ok' text if none
* specified.
*/
if(!OKText)
OKText = (SaveFlag ? LocaleString(MSG_GLOBAL_SAVE_TXT) : LocaleString(MSG_GLOBAL_OPEN_TXT));
/* Allocate the asl.library directory requester
* and display it.
*/
if(AslFileRequest = (struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
ASL_Window, Parent,
ASL_File, Name,
ASL_Dir, Directory,
Title ? ASL_Hail : TAG_IGNORE, Title,
ASL_FuncFlags, Flags | FILF_NEWIDCMP,
ASL_Pattern, Pattern,
ASL_OKText, OKText,
ASL_ExtFlags1, ExtFlags,
ASLFR_TextAttr, &UserFont,
TAG_MORE,GetDimensionTags(NULL,DimensionTags)))
{
if(AslRequestTags(AslFileRequest,TAG_DONE))
{
PutDimensionTags(NULL,AslFileRequest -> rf_LeftEdge,AslFileRequest -> rf_TopEdge,AslFileRequest -> rf_Width,AslFileRequest -> rf_Height);
if(!DirsOnly)
{
STRPTR FileName;
if(AslFileRequest -> rf_NumArgs > 1 && AslFileRequest -> rf_ArgList)
FileName = AslFileRequest -> rf_ArgList -> wa_Name;
else
FileName = AslFileRequest -> rf_File;
/* Do we have a valid file name? */
if(FileName)
{
/* Build a legal path/file string. */
strcpy(Buffer,AslFileRequest -> rf_Dir);
AddPart((STRPTR)Buffer,FileName,MAX_FILENAME_LENGTH);
Result = TRUE;
Forbid();
strcpy(DirBuffer,AslFileRequest -> rf_Dir);
Permit();
}
}
else
{
if(AslFileRequest -> rf_Dir[0])
{
strcpy(Buffer,AslFileRequest -> rf_Dir);
Result = TRUE;
Forbid();
strcpy(DirBuffer,AslFileRequest -> rf_Dir);
Permit();
}
}
}
}
/* We didn't get a file, no need to keep the
* file requester.
*/
if(!Result && AslFileRequest)
{
FreeAslRequest(AslFileRequest);
return(NULL);
}
else
{
if(SaveFlag && AskWrite)
{
if(GetFileSize(Buffer))
{
if(!MyEasyRequest(Parent,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_OVERWRITE_TXT),LocaleString(MSG_GLOBAL_REPLACE_CANCEL_TXT),FilePart(Buffer)))
{
FreeAslRequest(AslFileRequest);
return(NULL);
}
}
}
Forbid();
if(DefaultPattern)
strcpy(PatternBuffer,AslFileRequest -> rf_Pat);
Permit();
return(AslFileRequest);
}
}
/* MyEasyRequest(struct Window *Window,STRPTR Text,STRPTR Gadgets,...):
*
* Really quite simple varargs version of Intuition's
* EasyRequest requester.
*/
WORD __stdargs
MyEasyRequest(struct Window *Window,STRPTR Text,STRPTR Gadgets,...)
{
struct EasyStruct Easy;
va_list VarArgs;
LONG i,GadgetCount;
for(i = GadgetCount = 0 ; i < strlen(Gadgets) ; i++)
{
if(Gadgets[i] == '|')
GadgetCount++;
}
/* Standard data. */
Easy . es_StructSize = sizeof(struct EasyStruct);
Easy . es_Flags = NULL;
Easy . es_Title = LocaleString(MSG_TERMAUX_TERM_REQUEST_TXT);
Easy . es_TextFormat = Text;
Easy . es_GadgetFormat = Gadgets;
if(GadgetCount)
{
WORD Result;
if(GTLayoutBase)
LT_LockWindow(Window);
/* Use the argument array to build the
* requester and display it.
*/
va_start(VarArgs,Gadgets);
Result = EasyRequestArgs(Window,&Easy,NULL,VarArgs);
va_end(VarArgs);
if(GTLayoutBase)
LT_UnlockWindow(Window);
return(Result);
}
else
{
struct Window *ReqWindow;
if(GTLayoutBase)
LT_LockWindow(Window);
va_start(VarArgs,Gadgets);
if(ReqWindow = BuildEasyRequestArgs(Window,&Easy,IDCMP_RAWKEY,VarArgs))
{
ULONG IDCMP;
LONG Result;
FOREVER
{
WaitPort(ReqWindow -> UserPort);
IDCMP = NULL;
Result = SysReqHandler(ReqWindow,&IDCMP,FALSE);
if(!Result || (Result == -2 && !(IDCMP & IDCMP_RAWKEY)))
break;
}
FreeSysRequest(ReqWindow);
}
va_end(VarArgs);
if(GTLayoutBase)
LT_UnlockWindow(Window);
return(0);
}
}
/* CloseWindowSafely(struct Window *Window):
*
* Close a window freeing all messages pending at
* its user port (taken from example source code
* published once upon a time in Amiga Mail).
*/
VOID __regargs
CloseWindowSafely(struct Window *Window)
{
struct IntuiMessage *IntuiMessage;
struct Node *Successor;
Forbid();
IntuiMessage = (struct IntuiMessage *)Window -> UserPort -> mp_MsgList . lh_Head;
while(Successor = IntuiMessage -> ExecMessage . mn_Node . ln_Succ)
{
if(IntuiMessage -> IDCMPWindow == Window)
{
Remove(IntuiMessage);
ReplyMsg((struct Message *)IntuiMessage);
}
IntuiMessage = (struct IntuiMessage *)Successor;
}
Window -> UserPort = NULL;
ModifyIDCMP(Window,NULL);
Permit();
LT_DeleteWindowLock(Window);
CloseWindow(Window);
}
/* WaitTime(LONG Secs,LONG Micros):
*
* Wait a given period of time.
*/
VOID __regargs
WaitTime(LONG Secs,LONG Micros)
{
TimeRequest -> tr_node . io_Command = TR_ADDREQUEST;
TimeRequest -> tr_time . tv_secs = Secs;
TimeRequest -> tr_time . tv_micro = Micros;
DoIO(TimeRequest);
}
/* StopTime():
*
* Stop the running timer.
*/
VOID
StopTime()
{
if(TimerRunning)
{
if(!CheckIO(TimeRequest))
AbortIO(TimeRequest);
WaitIO(TimeRequest);
}
}
/* StartTime(LONG Secs,LONG Micros):
*
* Start the timer asynchronously.
*/
VOID __regargs
StartTime(LONG Secs,LONG Micros)
{
StopTime();
TimeRequest -> tr_node . io_Command = TR_ADDREQUEST;
TimeRequest -> tr_time . tv_secs = Secs;
TimeRequest -> tr_time . tv_micro = Micros;
ClrSignal(SIG_TIMER);
SendIO(TimeRequest);
TimerRunning = TRUE;
}
/* GetEnvDOS(STRPTR Name,STRPTR Buffer):
*
* Get the contents of a vanilla AmigaDOS environment
* variable.
*/
STRPTR __regargs
GetEnvDOS(STRPTR Name,STRPTR Buffer)
{
LONG Size;
BPTR File,SomeLock;
Buffer[0] = 0;
/* Is ENV: present? */
if(SomeLock = Lock("Env:",ACCESS_READ))
{
UBYTE SomeBuffer[MAX_FILENAME_LENGTH];
UnLock(SomeLock);
strcpy(SomeBuffer,"Env:");
strcat(SomeBuffer,Name);
/* Open the file. */
if(File = Open(SomeBuffer,MODE_OLDFILE))
{
/* Read the contents. */
Size = Read(File,Buffer,256);
Close(File);
if(Size > 0)
{
Buffer[Size] = 0;
return(Buffer);
}
}
}
return(NULL);
}
/* SetEnvDOS(STRPTR Name,STRPTR Value):
*
* Set the contents of a vanilla AmigaDOS environment
* variable.
*/
BYTE __regargs
SetEnvDOS(STRPTR Name,STRPTR Value)
{
UBYTE Buffer[MAX_FILENAME_LENGTH],*Destination;
LONG Length;
BPTR File,FileLock;
BYTE Success = TRUE;
WORD i;
for(i = 0 ; i < 2 ; i++)
{
if(i)
Destination = "EnvArc:";
else
Destination = "Env:";
/* Is ENV:/ENVARC: present? */
if(FileLock = Lock(Destination,ACCESS_READ))
{
UnLock(FileLock);
strcpy(Buffer,Destination);
strcat(Buffer,Name);
/* There already is a variable of that
* name in the environment storage
* directory.
*/
if(FileLock = Lock(Buffer,ACCESS_WRITE))
{
UnLock(FileLock);
/* Delete the variable. */
if(!DeleteFile(Buffer))
{
Success = FALSE;
continue;
}
}
/* Set the new variable. */
if(Length = strlen(Value))
{
if(File = Open(Buffer,MODE_NEWFILE))
{
if(Write(File,Value,Length) != Length)
{
Close(File);
DeleteFile(Buffer);
Success = FALSE;
}
else
{
Close(File);
AddProtection(Buffer,FIBF_EXECUTE);
}
}
else
Success = FALSE;
}
}
else
Success = FALSE;
}
return(Success);
}
/* BumpWindow(struct Window *SomeWindow):
*
* Bring a window to the front (and shift the screen
* back to its initial position).
*/
VOID __regargs
BumpWindow(struct Window *SomeWindow)
{
if(SomeWindow)
{
if(SomeWindow -> WScreen -> LeftEdge > 0)
{
if(SomeWindow -> WScreen -> TopEdge > 0)
MoveScreen(SomeWindow -> WScreen,-SomeWindow -> WScreen -> LeftEdge,-SomeWindow -> WScreen -> TopEdge);
else
MoveScreen(SomeWindow -> WScreen,-SomeWindow -> WScreen -> LeftEdge,0);
}
else
{
if(SomeWindow -> WScreen -> TopEdge > 0)
MoveScreen(SomeWindow -> WScreen,0,-SomeWindow -> WScreen -> TopEdge);
}
ScreenToFront(SomeWindow -> WScreen);
ActivateWindow(SomeWindow);
}
}
/* PushWindow(struct Window *Window):
*
* Push/PopWindow implement a single lifo window stack
* which always updates the window to activate when
* LSHIFT+RSHIFT+RETURN is pressed. This routine will
* push a window on the stack.
*/
VOID __regargs
PushWindow(struct Window *Window)
{
if(WindowStackPtr < 5)
{
WindowStack[WindowStackPtr++] = Window;
TopWindow = Window;
}
}
/* PopWindow():
*
* Remove topmost window from window stack.
*/
VOID
PopWindow()
{
if(WindowStackPtr > 0)
{
WindowStackPtr--;
if(WindowStackPtr)
TopWindow = WindowStack[WindowStackPtr - 1];
else
TopWindow = Window;
}
}
/* LoadMacros(STRPTR Name,struct MacroKeys *Keys):
*
* Load the keyboard macros from a file.
*/
BYTE __regargs
LoadMacros(STRPTR Name,struct MacroKeys *Keys)
{
struct IFFHandle *Handle;
BYTE Success = FALSE;
struct StoredProperty *Prop;
struct TermInfo *TermInfo;
LONG Error;
if(Handle = AllocIFF())
{
if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
{
InitIFFasDOS(Handle);
if(!(Error = OpenIFF(Handle,IFFF_READ)))
{
/* Collect version number ID if
* available.
*/
if(!(Error = PropChunks(Handle,(LONG *)VersionProps,1)))
{
/* The following line tells iffparse to stop at the
* very beginning of a `Type' chunk contained in a
* `TERM' FORM chunk.
*/
if(!(Error = StopChunk(Handle,ID_TERM,ID_KEYS)))
{
/* Parse the file... */
if(!ParseIFF(Handle,IFFPARSE_SCAN))
{
/* Did we get a version ID? */
if(Prop = FindProp(Handle,ID_TERM,ID_VERS))
{
TermInfo = (struct TermInfo *)Prop -> sp_Data;
/* Is it the file format we are able
* to read?
*/
if((TermInfo -> Version > CONFIG_FILE_VERSION) || (TermInfo -> Version == CONFIG_FILE_VERSION && TermInfo -> Revision > CONFIG_FILE_REVISION) || (TermInfo -> Version == 1 && TermInfo -> Revision < 6))
{
/* Probably an older revision. */
if(TermInfo -> Version == 1 && TermInfo -> Revision < 6)
{
memset(Keys,0,sizeof(struct MacroKeys));
if(ReadChunkBytes(Handle,Keys,10 * 256) == 10 * 256)
Success = TRUE;
else
Error = IoErr();
}
else
Error = ERR_OUTDATED;
}
else
{
/* The file read pointer is positioned
* just in front of the first data
* to be read, so let's don't disappoint
* iffparse and read it.
*/
if(ReadChunkBytes(Handle,Keys,sizeof(struct MacroKeys)) == sizeof(struct MacroKeys))
Success = TRUE;
else
Error = IoErr();
}
}
else
{
/* File was created by WriteIFFData previous
* to revision 1.4.
*/
memset(Keys,0,sizeof(struct MacroKeys));
if(ReadChunkBytes(Handle,Keys,10 * 256) == 10 * 256)
Success = TRUE;
else
Error = IoErr();
}
}
}
}
CloseIFF(Handle);
}
Close(Handle -> iff_Stream);
}
else
Error = IoErr();
FreeIFF(Handle);
}
else
Error = ERR_NO_MEM;
if(Error)
SetIoErr(Error);
return(Success);
}
/* WriteIFFData(STRPTR Name,APTR Data,LONG Size,ULONG Type):
*
* Write data to an IFF file (via iffparse.library).
*/
BYTE __regargs
WriteIFFData(STRPTR Name,APTR Data,LONG Size,ULONG Type)
{
struct IFFHandle *Handle;
BYTE Success = FALSE;
LONG Error;
/* Allocate a handle. */
if(Handle = AllocIFF())
{
/* Open an output stream. */
if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
{
/* Tell iffparse that this is
* a DOS handle.
*/
InitIFFasDOS(Handle);
/* Open the handle for writing. */
if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
{
/* Push outmost chunk onto stack. */
if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
{
/* Add a version identifier. */
if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
{
struct TermInfo TermInfo;
TermInfo . Version = CONFIG_FILE_VERSION;
TermInfo . Revision = CONFIG_FILE_REVISION;
/* Write the version data. */
if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
{
/* Pop the version chunk, i.e. write it to the file. */
if(Error = PopChunk(Handle))
Success = FALSE;
else
{
/* Push the real data chunk on the stack. */
if(!(Error = PushChunk(Handle,0,Type,IFFSIZE_UNKNOWN)))
{
/* Write the data. */
if(WriteChunkBytes(Handle,Data,Size) == Size)
Success = TRUE;
else
Error = IoErr();
/* Pop the data chunk. */
if(Success)
{
if(Error = PopChunk(Handle))
Success = FALSE;
}
}
else
Success = FALSE;
}
}
else
{
Error = IoErr();
Success = FALSE;
}
}
/* Seems that we're done, now try to pop the FORM chunk
* and return.
*/
if(Success)
{
if(Error = PopChunk(Handle))
Success = FALSE;
}
}
/* Close the handle (flush any pending data). */
CloseIFF(Handle);
}
/* Close the DOS handle itself. */
Close(Handle -> iff_Stream);
}
else
Error = IoErr();
/* And free the IFF handle. */
FreeIFF(Handle);
}
else
Error = ERR_NO_MEM;
if(Success)
AddProtection(Name,FIBF_EXECUTE);
if(Error)
SetIoErr(Error);
return(Success);
}
/* ReadIFFData(STRPTR Name,APTR Data,LONG Size,ULONG Type):
*
* Read data from a `TERM' FORM chunk contained in an IFF file.
*/
BYTE __regargs
ReadIFFData(STRPTR Name,APTR Data,LONG Size,ULONG Type)
{
struct IFFHandle *Handle;
BYTE Success = FALSE;
struct StoredProperty *Prop;
struct TermInfo *TermInfo;
LONG Error = 0;
if(Handle = AllocIFF())
{
if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
{
InitIFFasDOS(Handle);
if(!(Error = OpenIFF(Handle,IFFF_READ)))
{
/* Collect version number ID if
* available.
*/
if(!(Error = PropChunks(Handle,(LONG *)VersionProps,1)))
{
/* The following line tells iffparse to stop at the
* very beginning of a `Type' chunk contained in a
* `TERM' FORM chunk.
*/
if(!(Error = StopChunk(Handle,ID_TERM,Type)))
{
/* Parse the file... */
if(!ParseIFF(Handle,IFFPARSE_SCAN))
{
/* Did we get a version ID? */
if(Prop = FindProp(Handle,ID_TERM,ID_VERS))
{
TermInfo = (struct TermInfo *)Prop -> sp_Data;
/* Is it the file format we are able
* to read?
*/
if((TermInfo -> Version > CONFIG_FILE_VERSION) || (TermInfo -> Version == CONFIG_FILE_VERSION && TermInfo -> Revision > CONFIG_FILE_REVISION) || (TermInfo -> Version == 1 && TermInfo -> Revision < 6))
{
Error = ERR_OUTDATED;
Success = FALSE;
}
else
{
struct ContextNode *Chunk = CurrentChunk(Handle);
if(Chunk -> cn_Size < Size)
Size = Chunk -> cn_Size;
/* The file read pointer is positioned
* just in front of the first data
* to be read, so let's don't disappoint
* iffparse and read it.
*/
if(ReadChunkBytes(Handle,Data,Size) == Size)
Success = TRUE;
else
Error = IoErr();
}
}
}
}
}
CloseIFF(Handle);
}
Close(Handle -> iff_Stream);
}
else
Error = IoErr();
FreeIFF(Handle);
}
if(Error)
SetIoErr(Error);
return(Success);
}
/* SplitFileName():
*
* Split a full file name into a file and a drawer name.
*/
VOID __regargs
SplitFileName(STRPTR FullName,STRPTR *FileName,STRPTR DrawerName)
{
if(FilePart(FullName) == FullName)
{
*DrawerName = 0;
*FileName = FullName;
}
else
{
STRPTR Dummy;
strcpy(DrawerName,FullName);
Dummy = PathPart(DrawerName);
*Dummy = 0;
*FileName = FilePart(FullName);
}
}
/* CreateList():
*
* Create a small, empty list.
*/
struct List *
CreateList()
{
struct List *List = (struct List *)AllocVecPooled(sizeof(struct MinList),MEMF_ANY);
if(List)
NewList(List);
return(List);
}
/* DeleteList():
*
* Free the contents of a list and the list itself.
*/
VOID __regargs
DeleteList(struct List *List)
{
if(List)
{
struct Node *Node,
*Next;
for(Node = List -> lh_Head ; Next = Node -> ln_Succ ; Node = Next)
FreeVecPooled(Node);
FreeVecPooled(List);
}
}
/* BackfillRoutine():
*
* Window layer backfill routine.
*/
ULONG __asm __saveds
BackfillRoutine(register __a0 struct Hook *Hook,register __a1 struct {ULONG Layer; struct Rectangle Bounds;} *Bounds,register __a2 struct RastPort *RPort)
{
struct RastPort RastPort = *RPort;
RPort = &RastPort;
RPort -> Layer = NULL;
SetAPen(RPort,DrawInfo -> dri_Pens[BACKGROUNDPEN]);
SetDrMd(RPort,JAM1);
RectFill(RPort,Bounds -> Bounds . MinX,Bounds -> Bounds . MinY,Bounds -> Bounds . MaxX,Bounds -> Bounds . MaxY);
return(TRUE);
}
struct NameSegment
{
UBYTE String[63],
Separator;
};
STATIC UBYTE * __regargs
GetNameSegment(struct NameSegment *NameSegment,UBYTE *cp,WORD i)
{
UBYTE *xp = NameSegment[i] . String;
while (*cp && !strchr("._+-,@~=",*cp))
*xp++ = *cp++;
*xp = '\0';
NameSegment[i] . Separator = *cp;
if (*cp)
cp++;
if(NameSegment[i] . String[0] || NameSegment[i] . Separator)
return(cp);
else
return(NULL);
}
STATIC VOID __regargs
CopyNameSegment(struct NameSegment *NameSegment,UBYTE *Destination,WORD Zap)
{
UBYTE *cp = Destination,*xp;
for(xp = NameSegment[0] . String ; *xp ; )
*cp++ = *xp++;
if(NameSegment[0] . Separator)
{
register WORD i;
*cp++ = NameSegment[0] . Separator;
for(i = Zap + 1 ; ; i++)
{
for(xp = NameSegment[i] . String ; *xp ; )
*cp++ = *xp++;
if(NameSegment[i] . Separator)
*cp++ = NameSegment[i] . Separator;
else
{
if(!NameSegment[i] . String[0])
break;
}
}
}
*cp = 0;
}
/* ShrinkName():
*
* Shrink a file name down to a number of characters, if
* possible preserving the structure of the name. Algorithm
* courtesy of the "shrink" program by Simon Brown,
* Edinburgh University.
*/
UBYTE * __regargs
ShrinkName(const UBYTE *Source,UBYTE *Destination,WORD MaxLength,BOOLEAN FixSuffix)
{
#define MAXSEGS 10
struct NameSegment NameSegment[MAXSEGS];
WORD i,NumSegments,SuffixLength,Remainder,Delete,Total,Zap = 0;
UBYTE *OldPtr = (UBYTE *)Source;
for(i = 0 ; i < MAXSEGS && (OldPtr = GetNameSegment(NameSegment,OldPtr,i)) ; i++);
if(i < MAXSEGS)
{
NumSegments = i - 1;
if((NumSegments * 2) < MaxLength)
{
SuffixLength = strlen(NameSegment[NumSegments] . String);
if(SuffixLength > MaxLength - NumSegments - 1)
{
SuffixLength = MaxLength - (2 * NumSegments) - 1;
NameSegment[NumSegments] . String[SuffixLength - 1] = 0;
}
else
{
if (SuffixLength + NumSegments > MaxLength-NumSegments-1)
Zap = NumSegments - (MaxLength-SuffixLength)/2;
}
if(NumSegments >= 1)
{
for(i = Zap + 1 ; i <= NumSegments ; i++)
{
if(NameSegment[i] . Separator)
SuffixLength++;
}
if(NameSegment[0] . Separator)
SuffixLength++;
Remainder = MaxLength - SuffixLength;
Delete = Remainder / NumSegments;
Total = SuffixLength;
for(i = Zap + 1 ; i < NumSegments ; i++)
{
NameSegment[i] . String[Delete] = 0;
Total += Delete;
}
NameSegment[0] . String[MaxLength - Total] = 0;
}
CopyNameSegment(NameSegment,Destination,Zap);
}
else
strcpy(Destination,Source);
}
else
strcpy(Destination,Source);
if(FixSuffix)
{
BOOLEAN GotDot = FALSE;
LONG Len = strlen(Destination),Dots;
for(i = Dots = 0 ; i < Len ; i++)
{
if(Destination[i] == '.')
Dots++;
}
if(!Dots)
{
if(Len < 4)
strcat(Destination,".___");
else
Destination[Len - 4] = '.';
}
for(i = Len - 1 ; i >= 0 ; i--)
{
if(Destination[i] == '.')
{
if(GotDot)
Destination[i] = '_';
else
GotDot = TRUE;
}
if(Destination[i] == '\\')
Destination[i] = '-';
}
}
return(Destination);
}
/* BuildFontName(STRPTR Destination,const STRPTR Name,LONG Size):
*
* Build a font name and size string from given
* information (raw name and size).
*/
VOID __regargs
BuildFontName(STRPTR Destination,const STRPTR Name,LONG Size)
{
UBYTE LocalBuffer[50];
LONG Len;
strcpy(LocalBuffer,FilePart((STRPTR)Name));
Len = strlen(LocalBuffer);
if(Len > 5)
{
if(!Stricmp(&LocalBuffer[Len - 5],".font"))
LocalBuffer[Len - 5] = 0;
}
SPrintf(Destination,"%s %ld",LocalBuffer,Size);
}
/* CreateMenuGlyphs():
*
* Create scaled glyphs for pull-down menus.
*/
BOOLEAN __regargs
CreateMenuGlyphs(struct Screen *Screen,struct DrawInfo *DrawInfo,struct Image **AmigaPtr,struct Image **CheckPtr)
{
struct Image *AmigaGlyph,
*CheckGlyph;
LONG AspectX,AspectY,
Size,FontHeight;
FontHeight = DrawInfo -> dri_Font -> tf_Baseline + 2;
if(Screen -> Flags & SCREENHIRES)
Size = SYSISIZE_MEDRES;
else
Size = SYSISIZE_LOWRES;
AspectX = DrawInfo -> dri_Resolution . X;
AspectY = DrawInfo -> dri_Resolution . Y;
if(AmigaGlyph = NewObject(NULL,SYSICLASS,
SYSIA_DrawInfo, DrawInfo,
SYSIA_Size, Size,
SYSIA_Which, AMIGAKEY,
IA_Left, 0,
LA_Top, 0,
IA_Width, (FontHeight * 3 * AspectY) / (2 * AspectX),
IA_Height, FontHeight,
TAG_DONE))
{
if(!(CheckGlyph = NewObject(NULL,SYSICLASS,
SYSIA_DrawInfo, DrawInfo,
SYSIA_Size, Size,
SYSIA_Which, MENUCHECK,
IA_Left, 0,
LA_Top, 0,
IA_Width, (FontHeight * AspectY) / AspectX,
IA_Height, FontHeight,
TAG_DONE)))
{
DisposeObject(AmigaGlyph);
AmigaGlyph = NULL;
}
}
if(AmigaGlyph && CheckGlyph)
{
*AmigaPtr = AmigaGlyph;
*CheckPtr = CheckGlyph;
return(TRUE);
}
else
return(FALSE);
}
/* FixName(STRPTR Name):
*
* Build a correct AmigaDOS filename.
*/
VOID __regargs
FixName(STRPTR Name)
{
WORD NameLen = strlen(Name),
i;
/* Replace special characters. */
for(i = 0 ; i < NameLen ; i++)
{
switch(Name[i])
{
case ' ':
Name[i] = '_';
break;
case ':':
Name[i] = '.';
break;
case '/':
Name[i] = '\\';
break;
case '\"':
Name[i] = '\'';
break;
}
}
/* Truncate the name. */
if(NameLen > 31)
Name[31] = 0;
}
/* ShowError(struct Window *Window,LONG Primary,LONG Secondary,STRPTR String):
*
* Display an error message, in human readable form if possible.
*/
VOID __regargs
ShowError(struct Window *Window,LONG Primary,LONG Secondary,STRPTR String)
{
STATIC LONG LocalErrors[][2] =
{
ERR_SAVE_ERROR, MSG_ERR_COULD_NOT_SAVE_FILE_TXT,
ERR_LOAD_ERROR, MSG_ERR_COULD_NOT_LOAD_FILE_TXT,
ERR_NO_MEM, MSG_ERR_NO_MEM_TXT,
ERR_OUTDATED, MSG_ERR_OUTDATED_TXT,
ERR_EXECUTE_ERROR, MSG_ERR_COULD_NOT_EXECUTE_PROGRAM_TXT,
ERR_FILE_NOT_FOUND, MSG_VERIFY_NO_FILE_TXT,
ERR_DRAWER_NOT_FOUND, MSG_VERIFY_DRAWER_NOT_FOUND_TXT,
ERR_PROGRAM_NOT_FOUND, MSG_VERIFY_NO_PROGRAM_TXT,
ERR_NOT_A_FILE, MSG_VERIFY_DRAWER_NOT_A_FILE_TXT,
ERR_NOT_A_DRAWER, MSG_VERIFY_FILE_NOT_A_DRAWER_TXT,
IFFERR_NOMEM, MSG_IFFERR_NOMEM_TXT,
IFFERR_READ, MSG_IFFERR_READ_TXT,
IFFERR_WRITE, MSG_IFFERR_WRITE_TXT,
IFFERR_SEEK, MSG_IFFERR_SEEK_TXT,
IFFERR_MANGLED, MSG_IFFERR_MANGLED_TXT,
IFFERR_NOTIFF, MSG_IFFERR_NOTIFF_TXT,
0, 0
};
STRPTR PrimaryError = NULL,
SecondaryError = NULL;
if(Primary)
{
LONG i;
for(i = 0 ; LocalErrors[i][0] ; i++)
{
if(LocalErrors[i][0] == Primary)
{
PrimaryError = LocaleString(LocalErrors[i][1]);
break;
}
}
if(!PrimaryError)
{
STATIC UBYTE __far Buffer[256];
Fault(Primary,"",Buffer,256);
PrimaryError = Buffer + 2;
}
}
if(Secondary)
{
LONG i;
for(i = 0 ; LocalErrors[i][0] ; i++)
{
if(LocalErrors[i][0] == Secondary)
{
SecondaryError = LocaleString(LocalErrors[i][1]);
break;
}
}
if(!SecondaryError)
{
STATIC UBYTE __far Buffer[256];
Fault(Secondary,"",Buffer,256);
SecondaryError = Buffer + 2;
}
}
if(PrimaryError)
{
if(String)
MyEasyRequest(Window,PrimaryError,LocaleString(MSG_GLOBAL_CONTINUE_TXT),String,SecondaryError);
else
MyEasyRequest(Window,PrimaryError,LocaleString(MSG_GLOBAL_CONTINUE_TXT),SecondaryError);
}
}
struct RendezvousData * __saveds __asm
RendezvousLogin(register __a0 struct MsgPort *ReadPort,register __a1 struct MsgPort *WritePort,register __a2 struct TagItem *TagList)
{
struct RendezvousData *Data;
if(Data = (struct RendezvousData *)AllocVecPooled(sizeof(struct RendezvousData),MEMF_ANY | MEMF_CLEAR))
{
struct DataMsg Msg;
InitMsgItem(&Msg,TaskDestructor);
Msg . Type = DATAMSGTYPE_RENDEZVOUS;
Msg . Data = (UBYTE *)SysBase -> ThisTask;
Forbid();
ClrSignal(SIGBREAKF_CTRL_F);
PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
Wait(SIGBREAKF_CTRL_F);
Permit();
if(ReadRequest && WriteRequest)
{
struct List *UploadList;
CopyMem(ReadRequest,&Data -> rd_ReadRequest,sizeof(struct IOExtSer));
Data -> rd_ReadRequest . IOSer . io_Message . mn_ReplyPort = ReadPort;
CopyMem(WriteRequest,&Data -> rd_WriteRequest,sizeof(struct IOExtSer));
Data -> rd_WriteRequest . IOSer . io_Message . mn_ReplyPort = WritePort;
if(Window)
Data -> rd_Screen = Window -> WScreen;
NewList(&Data -> rd_UploadList);
NewList(&Data -> rd_DownloadList);
NewList(&Data -> rd_SentList);
NewList(&Data -> rd_ReceivedList);
if(UploadList = GetUploadList())
{
struct Node *Node,*Next;
for(Node = UploadList -> lh_Head ; Next = Node -> ln_Succ ; Node = Next)
AddTail(&Data -> rd_UploadList,Node);
FreeVecPooled(UploadList);
}
Data -> rd_SendPath = Config -> PathConfig -> BinaryUploadPath;
Data -> rd_ReceivePath = Config -> PathConfig -> BinaryDownloadPath;
Data -> rd_Options = "";
}
else
{
FreeVecPooled(Data);
Data = NULL;
}
}
return(Data);
}
VOID __saveds __asm
RendezvousLogoff(register __a0 struct RendezvousData *Data)
{
if(Data)
{
struct Node *Node,*Next;
for(Node = Data -> rd_UploadList . lh_Head ; Next = Node -> ln_Succ ; Node = Next)
FreeVecPooled(Node);
for(Node = Data -> rd_DownloadList . lh_Head ; Next = Node -> ln_Succ ; Node = Next)
FreeVecPooled(Node);
for(Node = Data -> rd_SentList . lh_Head ; Next = Node -> ln_Succ ; Node = Next)
FreeVecPooled(Node);
for(Node = Data -> rd_ReceivedList . lh_Head ; Next = Node -> ln_Succ ; Node = Next)
FreeVecPooled(Node);
FreeVecPooled(Data);
Signal(ThisProcess,SIG_HANDSHAKE);
}
}
struct Node * __saveds __asm
RendezvousNewNode(register __a0 STRPTR Name)
{
if(Name)
{
LONG Len;
if(Len = strlen(Name))
{
struct Node *Node;
if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + Len + 1,MEMF_ANY))
{
memset(Node,0,sizeof(struct Node));
strcpy(Node -> ln_Name = (STRPTR)(Node + 1),Name);
return(Node);
}
}
}
return(NULL);
}
struct List * __regargs
BuildModeList(LONG *Index,ULONG DisplayMode,ULONG (* __asm ModeFilter)(register __a1 ULONG ID))
{
struct List *List;
LONG Count = 0;
*Index = 0;
if(List = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
{
struct DisplayInfo DisplayInfo;
ULONG SomeMode = INVALID_ID;
NewList(List);
while((SomeMode = NextDisplayInfo(SomeMode)) != INVALID_ID)
{
if(GetDisplayInfoData(NULL,(APTR)&DisplayInfo,sizeof(struct DisplayInfo),DTAG_DISP,SomeMode))
{
if((DisplayInfo . PropertyFlags & DIPF_IS_WB) && !DisplayInfo . NotAvailable)
{
STRPTR Name;
if(ModeFilter)
{
if(!(*ModeFilter)(SomeMode))
continue;
}
if(Name = GetModeName(SomeMode))
{
struct ModeNode *ModeNode;
if(ModeNode = (struct ModeNode *)AllocVecPooled(sizeof(struct ModeNode) + strlen(Name) + 1,MEMF_ANY))
{
ModeNode -> VanillaNode . ln_Name = (STRPTR)(ModeNode + 1);
strcpy(ModeNode -> VanillaNode . ln_Name,Name);
ModeNode -> DisplayID = SomeMode;
AddTail(List,ModeNode);
Count++;
}
}
}
}
}
}
if(Count)
{
struct ModeNode *Node,
*Next;
for(Node = (struct ModeNode *)List -> lh_Head ; Node -> VanillaNode . ln_Succ ; Node = (struct ModeNode *)Node -> VanillaNode . ln_Succ)
{
if(!(Node -> DisplayID & MONITOR_ID_MASK))
{
for(Next = (struct ModeNode *)List -> lh_Head ; Next -> VanillaNode . ln_Succ ; Next = (struct ModeNode *)Next -> VanillaNode . ln_Succ)
{
if((Node -> DisplayID & ~MONITOR_ID_MASK) == (Next -> DisplayID & ~MONITOR_ID_MASK) && Next != Node)
Node -> DisplayID = INVALID_ID;
}
}
for(Next = (struct ModeNode *)List -> lh_Head ; Next -> VanillaNode . ln_Succ ; Next = (struct ModeNode *)Next -> VanillaNode . ln_Succ)
{
if(Node -> DisplayID == Next -> DisplayID && Next != Node)
Next -> DisplayID = INVALID_ID;
}
}
for(Node = (struct ModeNode *)List -> lh_Head ; Next = (struct ModeNode *)Node -> VanillaNode . ln_Succ ; Node = Next)
{
if(Node -> DisplayID == INVALID_ID)
{
Count--;
Remove(Node);
FreeVecPooled(Node);
}
}
}
if(Count)
{
struct ModeNode *Node,
*Next;
for(Count = 0, Node = (struct ModeNode *)List -> lh_Head ; Next = (struct ModeNode *)Node -> VanillaNode . ln_Succ ; Node = Next)
{
if(Node -> DisplayID == DisplayMode)
{
*Index = Count;
break;
}
}
return(List);
}
else
{
DeleteList(List);
return(NULL);
}
}
/* IsAssign(STRPTR Name):
*
* Does a name refer to an assignment?
*/
BOOLEAN __regargs
IsAssign(STRPTR Name)
{
WORD NameLen = strlen(Name) - 1;
BOOLEAN Result = FALSE;
/* Does it end with a colon? */
if(Name[NameLen] == ':')
{
struct DosList *DosList;
/* Lock the list of assignments for reading. */
DosList = AttemptLockDosList(LDF_ASSIGNS | LDF_READ);
/* Make sure the v37 bug doesn't catch us. */
if(((ULONG)DosList) > 1)
{
STRPTR AssignName;
/* Scan the list... */
while(DosList = NextDosEntry(DosList,LDF_ASSIGNS))
{
/* Convert the name from icky
* BCPL to `C' style string.
*/
AssignName = (STRPTR)BADDR(DosList -> dol_Name);
/* Does the name length match? */
if(AssignName[0] == NameLen)
{
/* Does the name itself match? */
if(!Strnicmp(&AssignName[1],Name,NameLen))
{
Result = TRUE;
break;
}
}
}
/* Unlock the list of assignments. */
UnLockDosList(LDF_ASSIGNS | LDF_READ);
}
}
/* Return the result. */
return(Result);
}
/* LockInAssign(BPTR TheLock,STRPTR TheAssignment):
*
* Check if a file lock is part of an assignment.
*/
BOOLEAN __regargs
LockInAssign(BPTR TheLock,STRPTR TheAssignment)
{
struct DevProc *DevProc = NULL;
struct MsgPort *FileSysTask = GetFileSysTask();
BOOLEAN Result = FALSE;
/* Loop until all assignments are
* processed.
*/
do
{
/* Get the default filesystem task
* in case we stumble upon NULL
* directory locks.
*/
if(DevProc = GetDeviceProc(TheAssignment,DevProc))
{
/* Set the default filesystem task. */
SetFileSysTask(DevProc -> dvp_Port);
/* Is the lock on the list? */
if(SameLock(DevProc -> dvp_Lock,TheLock) == LOCK_SAME)
Result = TRUE;
}
else
break;
}
while(DevProc && (DevProc -> dvp_Flags & DVPF_ASSIGN) && !Result);
/* Reset the default filesystem task. */
SetFileSysTask(FileSysTask);
/* Free device process data. */
if(DevProc)
FreeDeviceProc(DevProc);
return(Result);
}
/* DeleteBitMap(struct BitMap *BitMap):
*
* Delete a bitmap created by CreateBitMap().
*/
VOID __regargs
DeleteBitMap(struct BitMap *BitMap)
{
WaitBlit();
if(Kick30)
FreeBitMap(BitMap);
else
{
LONG i;
for(i = 0 ; i < BitMap -> Depth ; i++)
{
if(BitMap -> Planes[i])
FreeVec(BitMap -> Planes[i]);
}
FreeVecPooled(BitMap);
}
}
/* CreateBitMap(ULONG Width,ULONG Height,ULONG Depth,ULONG Flags,struct BitMap *Friend):
*
* Create a new bitmap with given properties.
*/
struct BitMap * __regargs
CreateBitMap(ULONG Width,ULONG Height,ULONG Depth,ULONG Flags,struct BitMap *Friend)
{
if(Kick30)
return(AllocBitMap(Width,Height,Depth,Flags,Friend));
else
{
struct BitMap *BitMap;
LONG Plus;
if(Depth > 8)
Plus = (Depth - 8) * sizeof(PLANEPTR);
else
Plus = 0;
if(BitMap = (struct BitMap *)AllocVecPooled(sizeof(struct BitMap) + Plus,MEMF_CLEAR))
{
LONG i,PageSize;
InitBitMap(BitMap,Depth,Width,Height);
PageSize = BitMap -> BytesPerRow * BitMap -> Rows;
for(i = 0 ; i < BitMap -> Depth ; i++)
{
if(!(BitMap -> Planes[i] = (PLANEPTR)AllocVec(PageSize,MEMF_CHIP)))
{
LONG j;
for(j = 0 ; j < i ; j++)
FreeVec(BitMap -> Planes[j]);
FreeVecPooled(BitMap);
return(NULL);
}
}
if(Flags & BMF_CLEAR)
BltBitMap(BitMap,0,0,BitMap,0,0,Width,Height,0x00,(1 << Depth) - 1,NULL);
}
return(BitMap);
}
}
/* LaunchCommand(STRPTR Command):
*
* Launch a command, try to figure out if it's an ARexx
* command, a plain batch file or a program and act
* accordingly.
*/
LONG __regargs
LaunchCommand(STRPTR Command)
{
UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
BPTR Stream,
OutputStream;
APTR OldConsoleTask = ThisProcess -> pr_ConsoleTask;
BOOL IsScript = FALSE,
IsRexx = FALSE;
LONG Result;
BPTR CommandFile;
UBYTE NameBuffer[MAX_FILENAME_LENGTH];
BPTR FileLock;
STRPTR OtherName;
WORD i;
/* Chop off the arguments. */
memcpy(NameBuffer,Command,MAX_FILENAME_LENGTH - 1);
NameBuffer[MAX_FILENAME_LENGTH - 1] = 0;
for(i = 0 ; i < MAX_FILENAME_LENGTH ; i++)
{
if(NameBuffer[i] == ' ')
{
NameBuffer[i] = 0;
break;
}
}
/* Now do something useful. Check if the command
* could be an ARexx script.
*/
if(CommandFile = Open(NameBuffer,MODE_OLDFILE))
{
LONG Len;
/* 256 bytes may be not be enough, but then
* we're only guessing.
*/
if((Len = Read(CommandFile,LocalBuffer,MAX_FILENAME_LENGTH)) > 0)
{
register UBYTE c;
LONG i;
for(i = 0 ; i < Len - 1 ; i++)
{
c = LocalBuffer[i];
/* Stop on invalid characters. */
if((c < ' ' && c != '\r' && c != '\n' && c != '\a') || (c >= 127 && c < 160))
break;
else
{
/* Looks like the typical
* introductory comment line.
*/
if(c == '/' && LocalBuffer[i + 1] == '*')
{
IsRexx = TRUE;
break;
}
}
}
}
Close(CommandFile);
}
/* Ok, second check. Does it have the script bit set? */
if(FileLock = Lock(NameBuffer,ACCESS_READ))
{
struct FileInfoBlock __aligned FileInfo;
if(Examine(FileLock,&FileInfo))
{
if(FileInfo . fib_Protection & FIBF_SCRIPT)
IsScript = TRUE;
}
UnLock(FileLock);
}
/* If it's an ARexx command, launch it. */
if(IsRexx)
{
SendARexxCommand(Command,TRUE);
return(0);
}
/* If it's a script command, prepend the "Execute "
* command. It's not perfect but it should work.
*/
if(IsScript)
{
if(OtherName = AllocVecPooled(strlen("Execute ") + strlen(Command) + 1,MEMF_ANY))
{
strcpy(OtherName,"Execute ");
strcat(OtherName,Command);
Command = OtherName;
}
}
else
OtherName = NULL;
if(WindowName[0])
{
UBYTE LocalName[MAXPUBSCREENNAME + 1];
if(Window)
{
if(!GetPubScreenName(Window -> WScreen,LocalName))
LocalName[0] = 0;
}
if(LocalName[0])
{
SPrintf(LocalBuffer,WindowName,LocalName);
Stream = Open(LocalBuffer,MODE_NEWFILE);
}
else
Stream = Open(WindowName,MODE_NEWFILE);
}
else
Stream = NULL;
if(GoodStream(Stream))
{
ThisProcess -> pr_ConsoleTask = ((struct FileHandle *)BADDR(Stream)) -> fh_Type;
OutputStream = Open("*",MODE_NEWFILE);
}
else
OutputStream = NULL;
if(Stream && OutputStream)
{
Result = SystemTags(Command,
SYS_Input, Stream,
SYS_Output, OutputStream,
SYS_UserShell, TRUE,
TAG_DONE);
}
else
{
Result = SystemTags(Command,
SYS_UserShell, TRUE,
TAG_DONE);
}
if(OutputStream)
Close(OutputStream);
if(Stream)
Close(Stream);
ThisProcess -> pr_ConsoleTask = OldConsoleTask;
if(OtherName)
FreeVecPooled(OtherName);
return(Result);
}
/* AskDial(struct Window *Parent):
*
* This is called when the user is about to start dialing. If the
* dial button/menu item is available with the protective mode
* enabled, a message will be displayed, asking if the line
* should be hung up before proceeding.
*/
BOOL __regargs
AskDial(struct Window *Parent)
{
if(!DialItemsAvailable)
{
if(MyEasyRequest(Parent,LocaleString(MSG_CANNOT_DIAL_BECAUSE_TXT),LocaleString(MSG_DIAL_CANCEL_TXT)))
FullHangup(TRUE);
else
return(FALSE);
}
return(TRUE);
}